On Nested Justification Systems

Abstract Justification theory is a general framework for the definition of semantics of rule-based languages that has a high explanatory potential. Nested justification systems, first introduced by Denecker et al., allow for the composition of justification systems. This notion of nesting thus enables the modular definition of semantics of rule-based languages, and increases the representational capacities of justification theory. As we show in this paper, the original characterization of semantics for nested justification systems leads to the loss of information relevant for explanations. In view of this problem, we provide an alternative characterization of their semantics and show that it is equivalent to the original one. Furthermore, we show how nested justification systems allow representing fixpoint definitions.


Introduction
Justification theory (Denecker et al. 2015) is a general framework for the definition of semantics of rule-based languages that allows to design languages with high explanatory potential, as the justification-based semantics give an immediate explanation of the truthvalue of a fact. In more detail, a justification is a tree of facts, where children of a The merging-based characterisation brings the explanatory potential of standard justification theory to nested justification systems. This is promising not just for nested fixpoint definitions, which we study in the current paper, but also for other applications of nesting, such as the modular definition of new language constructs. Furthermore, due to the general nature of justification theory, as well as of our characterisations and results, our results also apply to any future branch evaluations.
Outline of the paper: The rest of this paper is structured as follows: necessary preliminaries on justification theory are given in Section 2. In Section 3, nested justification systems are defined. The first characterisation of semantics for nested justification systems, compression-based characterisation, is recalled and studied in Section 4. In Section 5, the merging-based characterisation is introduced. These two characterisations are shown equivalent in Section 6. Nested justification systems are shown to capture fixpoint definitions in Section 7. The paper is concluded in view of related work in Section 8.

Preliminaries
We use the formalization of justification theory of Marynissen et al. (2020). We first give and explain all necessary definitions, and afterwards illustrate them with an example.
In the rest of this paper, let F be a set, referred to as a fact space, such that L = {t, f , u} ⊆ F, where t, f and u have the respective meaning true, false, and unknown. The elements of F are called facts. The set L behaves as the three-valued logic with truth order f ≤ t u ≤ t t. We assume that F is equipped with an involution ∼ : F → F (i.e. a bijection that is its own inverse) such that ∼t = f , ∼u = u, and ∼x = x for all x = u. For any fact x, ∼x is called the complement of x. An example of a fact space is the set of literals over a propositional vocabulary Σ extended with L where ∼ maps a literal to its negation. For any set A we define ∼A to be the set of elements of the form ∼a for a ∈ A. We distinguish two types of facts: defined and open facts. The former is accompanied by a set of rules that determine their truth value. The truth value of the latter is not governed by the rule system but comes from an external source or is fixed (as is the case for logical facts), and only occur in bodies of rules.
The set of open facts is denoted as F o := F \ F d . An element (x, A) ∈ R is called a rule with head x and body (or case) A. The set of cases of x in JF is denoted as JF (x). Rules (x, A) ∈ R are denoted as x ← A and if A = {y 1 , . . . , y n }, we often write x ← y 1 , . . . , y n . In justification theory, defined facts are evaluated by constructing justifications for them. Justifications are directed graphs, where the set truth of the (labels of the) children of a node forms a reason (or argument, or cause, depending on the context) for the truth of the (label of the) node itself. Such reasons are not necessarily convincing: for example if they are based on a parameter that is not true, or might lead to cyclic argumentation. Therefore, branches in justification trees are evaluated using branch evaluations.

Definition 2.2
Let JF = F, F d , R be a justification frame. A justification J in JF is a (possibly infinite) directed labelled graph (N, F d , E, ), where N are the nodes, E the vertices, and : N → F d is a labelling function, such that (1) the underlying undirected graph is a forest, that is, is acyclic; and (2) for every internal node n ∈ N it holds that We write J(x) for the set of justifications that have a node labelled x. A justification is locally complete if it has no leaves with label in F d . We call x ∈ F d a root of a justification J if there is a node n labelled x such that every node is reachable from n in J.

Remark 2.3
In some works, justifications are formalized as graphs and the justifications as defined here are then called tree-like justifications (Marynissen et al. 2020). Since we restrict attention to the latter, we shall just use the term justification.

Definition 2.4
Let JF be a justification frame. A JF -branch is either an infinite sequence in F d or a finite non-empty sequence in F d followed by an element in F o . For a justification J in JF , a J-branch starting in x ∈ F d is a path in J starting in x that is either infinite or ends in a leaf of J. We write B J (x) to denote the set of J-branches starting in x.
Not all J-branches are JF -branches since they can end in nodes with a defined fact as label. However, if J is locally complete, any J-branch is also a JF -branch.
Definition 2.5 A branch evaluation B is a mapping that maps any JF -branch to an element in F for all justification frames JF . A justification frame JF together with a branch evaluation B form a justification system JS, which is presented as a quadruple F, F d , R, B .
A branch evaluation is parametric if every branch is mapped to an open fact. A justifi- The supported (completion) branch evaluation B sp maps x 0 → x 1 → · · · to x 1 . The Kripke-Kleene branch evaluation B KK maps finite branches to their last element and infinite branches to u. Let JF be a justification frame. A sign function on JF is a map sgn : F d → {−, +} such that sgn(x) = sgn(∼x) for all x ∈ F d . We denote F − := sgn −1 ({−}) and F + := sgn −1 ({+}). From now on, we fix a sign function on JF . We say that an infinite branch has a positive (respectively negative) tail if from some point onwards all elements are in F + (respectively F − ). The well-founded branch evaluation B wf maps finite branches to their last element. It maps infinite branches to t if they have a negative tail, to f if they have a positive tail and to u otherwise. The co-well-founded branch evaluation B cwf maps finite branches to their last element, infinite branches with a positive tail to t, infinite branches with a negative tail to f , and all other infinite branches to u. The stable (answer set) branch evaluation B st maps a branch x 0 → x 1 → · · · to the first element with a different sign than x 0 if it exists; otherwise b is mapped to B wf (b).
The final ingredient of the semantics of justification systems are interpretations, which are abstractions of possible states of affairs, formalized as an assignment of a truth value to each fact. A (three-valued) interpretation of F is a function I : F → L such that I(∼x) = ∼I(x) and I(l) = l for all l ∈ L. The set of interpretations of F is denoted by I F . We will call an interpretation two-valued if I(x) = u for all x = u. Given an interpretation I and a justification system JS, we can now evaluate the quality of justifications: the value assigned to a justification will be the least (in the truth order) value of its branches. The rationale behind this definition is that for a justification to be "good", all of the arguments it contains should be good as well. On top of this definition, we will define a notion of supported value of a fact, which is the value of its best justification. Indeed, in general we will not be interested in the existence of bad arguments why a fact holds, but only in the existence of its best arguments.
Let JS = F, F d , R, B be a justification system, I an interpretation of F, and J a locally complete justification in JS. Let x ∈ F d be a label of a node in J. The value of x ∈ F d by J under I is defined as val(J, x, I) = min b∈BJ (x) I(B(b)), where the minimum is taken with respect to ≤ t . The supported value of x ∈ F in JS under I is defined as We have the following JF -branches (we denote branches compactly in a graph-like fashion, that is a loop like b 3 denotes the infinite branch q → q → . . .): ∼q These branches are evaluated as follows:

S. Marynissen et al.
Let I be the interpretation with I(r) = I(p) = I(∼q) = t, J the justification for p made up of b 1 and b 2 , and JF = F, F d , R, B wf . We see that, for example, val(J, p, I) = min b∈BJ (p) I(B wf (b)) = t, and thus that SV(p, I) = I(p). In fact, it can be verified that this holds for every literal, that is, I is a JF -model. In I (still, under the well-founded semantics), J serves as an explanation as to why p is true: because ∼q and r are true. Simultaneously, J also explains why the facts r and ∼q are true. In the case of r, this is simply because it is an open fact (with value true). For ∼q, this explanation looks selfsupporting: the reason why ∼q holds is because ∼q holds. For negative facts, stable and well-founded semantics accept such cyclic branches: the reason is that this cycle actually represents the fact that the positive fact (q) can only be justified by cyclic justifications, and well-founded and stable semantics reject cyclic justifications for positive facts.

Nested justification systems
As outlined in the introduction, nested justifications, originally introduced by Denecker et al. (2015), allow for the modular definition of semantics, the representation of richer classes of logics and the combination of different semantics in different modules. In this section, we introduce nested justification systems formally. A nested justification system is essentially a tree structure of justification systems, meaning, that some systems are local to certain others, that is some facts occurring as an open fact in one component system are defined in another component system.
is parametric and all of its subsystems are parametric. We call a nested justification system compressible if for each i, JS i is parametric.
. . , JS k , we call (for i = 1, . . . , k) JS the parent system of JS i and JS i a child system of JS. Ancestor and descendant systems are defined analogously by transitively closing the parent, respectively, child relation. This defines a tree of nested justification systems, where the leaves have F dl = F d and k = 0, and thus correspond directly to an unnested justification system.
The factspace F consists of all the facts used in (some component system of) JS. The facts in F dl are those that are defined locally in the justification system, that is, in the rules R. The facts in F d are those that are either defined locally, or in some component system of JS. Every defined fact is either defined locally in the top system (F dl ), or in one of the subsystems (F i d ). Each child system JS i can use as opens only the opens of the root and the facts defined locally in the root. This has the consequence that facts defined in JS i do not appear as opens in JS j if i = j.
The inner system JS 1 is equal to the unnested system with F 1 dl = {p, ∼p, q, ∼q}, B 1 = B wf , and We summarize this nested justification system graphically as follows: This example also illustrates how different branch evaluations (e.g. B KK and B cwf ) can be combined in nested justification systems.
One notoriously difficult problem is the integration of aggregates in non-monotonic semantics of logic programming (Pelov et al. 2007;Faber et al. 2011;Gelfond and Zhang 2019;Alviano et al. 2021;Vanbesien et al. 2021). While we do not develop the full theory here, we conjecture that nested justification systems can shed light on the relations between different semantics. As a first step towards this goal, we will show on a single example how different semantics for aggregates can be obtained by plugging in a different nested system defining the aggregate atoms in question. The outer system will always simply be evaluated under the stable semantics.

Example 3.4
We consider a representation of an aggregate atLeastTwo expressing that at least two atoms among p, q and s are true.
For brevity and for emphasizing the relation with logic programming, we have here only written down the rules for positive facts. The rules for negative facts can be obtained automatically by means of a technique called complementation; more details can be found in Appendix A of the full version of this article . These systems differ only in their inner justification system, that is, in which justifications for the atom atLeastTwo they accept. The inner system is evaluated here (in both cases) under Kripke-Kleene semantics; however, since it is a non-recursive system, all major branch evaluations we discussed coincide. These two justification systems are inspired by the logic program which has one (two-valued) stable model, namely {p, q, s}, according to the FLP semantics  but no (two-valued) stable models according to the GZ semantics (Gelfond and Zhang 2019). We will show later that this is indeed what the semantics for nested justifications for the first respectively the second system.
In the following two sections, two different characterisations of the semantics for nested justification systems are given. In a nutshell, these characterisations both describe how to convert a nested justification system in a non-nested justification system. The first characterisation, called the compression-based characterisation, keeps the branch evaluation of the top system, but manipulates the rules to "squeeze in" all information about subsystems (their branch evaluation as well as their rules), while the second, mergingbased characterisation, keeps the rules of the original system intact, but creates a new branch evaluation based on all branch evaluations present in the system.

Compression-based characterisation of semantics for nested systems
The semantics for nested justification systems was originally introduced by Denecker et al. (2015). The basic idea is to compress a nested justification system in a regular justification system, starting from the leaves of the nesting tree and iteratively moving up. In a compressible nested system, the branch evaluations of subsystems are parametric and hence we know (by Proposition 3 of Marynissen et al. 2021 Intuitively, Flat(JS) is obtained by constructing a rule x ← A for every justification J for x, where A is obtained by simply taking the facts to which the branches in J starting in x are mapped by the branch evaluation B.

Example 4.2 (Example 3.3 ctd.)
In view of Example 2.8, the flattening of the inner justification system JS 1 has the following rules: In more detail, p ← t, r is obtained from the justification made up of b 1 and b 2 , and the fact that B KK (b 1 ) = t and B KK (b 2 ) = r. This is called flattening because every locally complete justification is reduced to a single rule. If B is parametric, justifications in this new system have only branches of length two. If these simple branches are mapped to their last element, then the flattening is equivalent to the original system. For parametric systems, flattening thus preserves the meaning of the original system:

Proposition 4.3
If JS 1 and JS 2 are parametric justification systems mapping a branch x → y to y, then: 1. JS 1 is equivalent to Flat(JS 1 ). 2. JS 1 and JS 2 are equivalent if and only if Flat(JS 1 ) and Flat(JS 2 ) are equivalent.
Notice that it immediately follows that if the preconditions of the above proposition are satisfied, then the JS 1 and Flat(JS 1 )-models coincide. As a consequence, flattening preserves the properties of the justification at hand. We should note, however, that the structure of the justification is lost: justifications in Flat(JS) are condensed down. We will come back to this later.
Flattening provides us with a way to evaluate inner definitions. The second operation needed for compression is unfolding, which allows to eliminate inner symbols from the outside definitions, by replacing facts at a lower level by a (flattened) case for that fact.

Definition 4.4
Let R be a set of rules, and R a set of rules for the facts X (the elements of X are the heads of the rules in R ). Take a rule x ← A in R. Let f be any function with domain A ∩ X such that for all y ∈ A ∩ X, y ← f (y) is a rule in R (the function f chooses a rule for each y ∈ A ∩ X). The unfolding of x ← A with respect to f is the rule Let F x←A be the set of such functions f . Then the unfolding of x ← A with respect to R is the set The unfolding of R with respect to R is In a nutshell, Unfold (X,R ) (R) is obtained by replacing, in each x ← y 1 , . . . , y n ∈ R, each fact y i defined in R by the body facts A of a rule y i ← A defining y i .

Example 4.5 (Examples 3.3 & 4.2 ctd.)
With all systems as defined previously, we see that On the basis of the unfolding of a set of rules we can define the unfolding of a justification system, obtained by unfolding the rules of the parent system with respect to the rules of the children systems, and keeping the rules for the lower-level facts (R s ): 650 S. Marynissen et al. Definition 4.6 Let JS = F, F d , F dl , R, B, JS 1 , . . . , JS k be a two-level nested compressible justification system. The unfolding of JS is The unfold-operation reduces the depth of the nesting tree and thus serves as a basis for the compression of a nested justification system (notice that since the subsystems JS i will have a smaller depth than JS, Compress(JS) is well-defined). .

Remark 4.8
Intuitively, the compression works as follows, described here for a two-level system JS with only one subsystem JS 1 = F 1 , F 1 d , R 1 , B 1 . First of all, JS 1 is flattened. We know from Proposition 4.3 that this preserves the meaning of the system, and in fact, it no longer matters which branch evaluation is used, provided that it maps branches of length 2 onto their last element. In other words, the original system and branch evaluation are consolidated into the flattened frame. The next step is to replace each occurrence (in JS) of each fact defined in JS 1 by all possible cases for it in the flattened system. If B 1 is parametric, each such case in the flattened system contains only fact that are either locally defined or open in JS. The result can then be evaluated without any knowledge of the branch evaluation or rules of JS 1 . While technically, the compressed system also contains a copy of R 1 , they are only there for recovering the value of facts in F 1 d ; they play no role for determining the value of facts in JS. In case B 1 is not parametric, this construction no longer works: the cases in the flattening can then contain facts that are locally defined in JF 1 . For this reason, compression was only defined for parametric branch evaluations by Denecker et al. (2015). We here slightly relax this condition, by allowing (in a compressible system) the outer branch evaluation to be non-parametric.

Example 4.9 (Example 4.5 ctd.)
We have already calculated Unfold (F 1 dl ,R 2 ) R 1 in Example 4.5. Since Unfold (F dl ,R 1 ) (R) contains only rule bodies with open facts, we see that Flat(Unfold (F dl ,R 1 ) (R)) = Unfold (F dl ,R 1 ) (R). We therefore obtain: and thus end up with an unnested justification system. It can be verified that the unique Compress(JS)-model is I with I(∼r) = I(p) = I(q) = f .

Example 4.10
We return to the nested justification system of Example 3.4. It can be verified that Compress(JS FLP ) is equal to (the complementation of) p ← t; q ← t; s ← p, s s ← p, q, s; s ← p, q; atLeastTwo ← p, q; atLeastTwo ← s, q; atLeastTwo ← p, s; The interpretation I with I(s) = I(p) = I(q) = t is the only two-valued Compress(JS FLP ). This interpretation indeed corresponds to the only stable model under the FLP semantics (mentioned above).
On the other hand, there are no two-valued Compress(JS GZ )-models. This can be seen by observing that Compress(JS GZ ) equals (the complementation of): q, ∼s; s ← p, s, ∼q; s ← p, q, s, ∼p; s ← p, q, s; atLeastTwo ← p, q, ∼s; atLeastTwo ← s, q, ∼p; atLeastTwo ← p, s, ∼q; atLeastTwo ← p, q In this section, the semantics of nested justifications in terms of compressions, originally proposed by Denecker et al. (2015) was described and studied. This characterisation of semantics of nested justification systems is the first one given in the literature. However, it does have a significant downside: the explanatory potential of justification systems is partially lost, since rules in lower levels of the justification system are compressed to their evaluation. For example, the definition of r in Example 3.3 is compressed to {r ← t, r, f }, and thus the explanatory potential of justification theory is completely lost. Indeed, intuitively, we have a justification in the original nested justification system that looks like the justification on the left of the figure below, and is obtained by constructing a justification on the basis of all (relevant) rules in JS: However, under the compression-based semantics, we obtain the justification on the right, where most information on the justification of r has been lost. Thus, from the point of view of explainable reasoning, it is preferable to be able to somehow evaluate the justification on the left while retaining semantic equivalence with the compression-based semantics. This is exactly what will be done in the next section.

Merging-based characterisation of semantics for nested systems
To avoid the loss of information with explanatory potential suffered by the compressionbased characterisation, the merging-based characterisation of semantics is now proposed.
The basic idea of the merging-based characterisation is to consolidate all component systems of the nested justification system in a justification system F, F d , R * , B * , where all rules of all component justification systems are simply gathered in R * . This also means that justification branches are now constructed on the basis of all rules occurring somewhere in the nested justification system, and not simply on the basis of one component justification system. The information about the nesting structure of the original system is not discarded, but taken into account in the merge branch evaluation B * . In more detail, for infinite branches b in R * , one looks for the highest component justification system JS in the nested justification system s.t. b contains infinitely many elements of locally defined facts of JS , and then applies the original branch evaluation B of the component system in question to the JS -branch b that corresponds to b. This formalizes the intuition that priority is given to the outermost semantics.

Definition 5.1
The merge Merge(JS) of JS is the justification system F, F d , R * , B * , where: • R * is the union of all the rules in JS.
• the merge branch evaluation B * w.r.t. JS is defined as follows: 1. if b is finite, then B * (b) is equal to the last element of b.
2. if b is infinite, then let JS be the unique 2 system equal to either JS or one of its descendant systems such that: The conditions in Definition 3.1 guarantee that branches in Merge(JS) are sequences of facts x 0 → x 1 → . . . s.t. x i is defined locally in a descendant or ancestor of x i+1 . This guarantees that the system JS indeed exists and is unique: if a branch has infinitely many occurrences of facts defined (locally) in two systems, then it must also go infinitely often through a common ancestor.

Example 5.2 (Example 3.3 ctd.)
Consider again JS as in Example 3.3. We have, among others, the justification for r in Merge(JS) on the left side of the following picture 4 ; on the right side, the individual branches have been unravelled and the corresponding "primed" branches are drawn: Notice that all literals in b 1 occur infinitely many times in b 1 . Since r is defined locally in JS, that is it occurs in F dl , we have to look at JS to evaluate b 1 with B . On the right side, the branch b 1 = r → r → . . . obtained from b 1 by removing all facts defined outside of JS is given. We now obtain B (b 1 ) by evaluating b 1 according to b 1 , that is, For b 2 and b 3 , we see that the highest justification system in which q respectively ∼q are defined is JS 1 . We therefore obtain the branches b 2 = q → q → . . . and b 3 = ∼q → ∼q → . . .. Since JS 1 uses the well-founded branch evaluation B wf , we Here, we can thus see the different branch evaluations of the component systems at work: for example, branches with infinite occurrences of positive literals are treated differently in view of the component justification system in which these literals are defined, and the branch evaluations used in these justification systems. In more detail, b 1 is evaluated to u since it is defined locally in JS, which uses the Kripke-Kleene evaluation, whereas b 3 is evaluated to f since it is defined in JS 2 , which uses the well-founded evaluation. Altogether, we see that for I(r) = t, I(q) = I(p) = f , it holds that SV(r, I) = t. In fact, it can be checked that I is the unique Compress(JS)-model, which is no coincidence as we will see next.

Equivalence of compression-and merging-based characterisations
Even though the compression-based and merging-based characterisation of semantics are based on quite different mechanisms, they give rise to the same evaluations for nested justification systems, that is, they are equivalent. Showing this is rather involved, and due to spatial limitations, the details are given in Appendix D of the full version of this article   logical facts (in fact, unless additional structure on the fact space is assumed, this will always be satisfied). We obtain the following theorem.
Theorem 6.1 Let a compressible nested justification system JS in which every branch evaluation maps finite branches to their last element, and infinite branches to logical facts. Then Compress(JS) and Merge(JS) are equivalent.
It immediately follows that for a justification system that satisfies all of the preconditions of Theorem 6.1, the Compress(JS)-models coincide with the Merge(JS)-models.

Remark 6.2
As mentioned in Remark 4.8, compression was only defined for so-called compressible branch evaluations to allow evaluating the different involved systems separately. For merging, this restriction does not play a role: here all branch evaluations are taken into account simultaneously, in the definition of B * . As such, we have not just given a novel characterization of the semantics of nested systems, but also significantly expanded its scope, by allowing non-parametric systems, such as stable or supported, to be nested.

FO(FD): Application to fixpoint definitions
FO(FD) (Hou et al. 2010) is a logic that integrates fixpoint definitions based on rules with first-order logic. Essentially, a least fixpoint definition (respectively greatest fixpoint definition) is defined inductively as an expression of the form D = R, Δ 1 , . . . , Δ m , ∇ 1 , . . . , ∇ n (respectively R, Δ 1 , . . . , Δ m , ∇ 1 , . . . , ∇ n ), where R is a set of rules and each Δ i is a least fixpoint definition and each ∇ j is a greatest fixpoint definition, s.t. every symbol is defined in at most one of R, Δ 1 , . . ., Δ m , ∇ 1 , . . ., ∇ n . Additionally, defined symbols are only allowed to occur positively in rule bodies. The semantics of FO(FD), explained in full detail in Appendix E of the full version of this article , is given in terms of (two-valued) interpretations, and is defined iteratively, by means of an immediate consequence operator Γ D (I). Consistent with the idea of capturing a definition, a unique model according to these semantics is guaranteed to exist. The nested nature of fixpoint definitions comes into play when requirements of different levels conflict with each-other. In that case, intuitively, the highest level (the outermost definition) will be given priority.
As an example, restricted to the propositional case, consider: This fixpoint definition consists of two levels. The uppermost or global level is a least fixpoint definition of p, q and u, whereas the lower or inner level contains a greatest fixpoint definition of the atoms r, s and t. Intuitively, the semantics will ensure that the model of this definition corresponds to a greatest fixpoint of the immediate consequence operator based on the inner system, and a least fixpoint of the immediate consequence operator based on the outer system, together with the respective interpretation for the inner system. For example, the interpretation that assigns t to s, t and u, and f to p, q and r to f is a model of this fixpoint definition. We see that the cycle between p ← q ∨ r and r ← p gives rise to a conflict between the two levels: the greatest fixpoint nature of the lowest level would require us to make p and r true, whereas the least fixpoint nature of the highest level would require us to make p and r false. Since priority is given to the highest level, p and r are false in the defined interpretation. Nested justifications were partially inspired by FO(FD), and is therefore not surprising that FO(FD) can be captured using nested justifications. This way of assigning priority to higher levels in case of conflicting demands also shows up in the merging-based characterisation, where the highest component system is used to evaluate infinite branches.
For the propositional case, the translation is rather straightforward. Given a fixpoint definition D, JS D is defined as F, F d , F dl , R, B, {JS Δ1 , . . . , JS Δm , JS ∇1 , . . . , JS ∇n } , where B = B wf if D is a least fixpoint definition and B = B cwf if D is a greatest fixpoint definition. We can thus represent the nested justification system JS D as: p ← q ∨ r; q ← p; u ← s B cwf : r ← p; s ← t; s ← q; t ← s This translation is adequate, in the sense that a unique B wf -model (respectively B cwfmodel) that leaves no atoms u is guaranteed to exist and corresponds to the least (respectively greatest) fixpoint of the fixpoint definition. Notice that we replaced s ← t ∨ q by s ← t and s ← q. For more complex formulae, more work is required. For the full first-order case, the idea is essentially the same, but an intermediary system is included between JS D and JS Δ1 , . . . , JS Δm , JS ∇1 , . . . , JS ∇n to ensure that first-order formulae are treated adequately. This translation, as well as the correspondence results, are detailed in Appendix E of the full version of this article .

Conclusion, in view of related work
In this paper, we gave two characterisations of the semantics of nested justification systems, showed that these characterisations are equivalent and demonstrated how nested justifications can capture nested fixpoint definitions. The potential applications of nested justification systems are extensive, as they allow for the modular, and therefore straightforward, design of rule-based languages. A prime example is the definition of semantics for aggregates. Nested justification systems allow to separate the definition of semantics