II. Execution of Queries over a Web of Linked Data 97
6. A Traversal-Based Strategy 111
7.2. Formal Analysis
7.2.1. Examples for Incompleteness
Example 7.2 (cf. page 136) demonstrates a particular execution of Algorithm 7.5 for a given CLD(M) query. This execution reports two valuations. These two valuations
Algorithm 7.5 Overall process for an iterator-based execution of CLD(M)query QB,S over a Web of Linked DataW.
1: n:=|B|
2: Select a logical plan (B, /) for B.
3: Create a data structure Dfor the currently discovered subweb ofW.
4: UseS,W, and Dto create root iterator I0 (as defined in Listing 7.3, page134).
5: fork:= 1ton do
6: Assume tpk ∈ B is the k-th triple pattern in B according to order /. Use tpk, Ik−1, W, and D to create link traversing iterator Ik (as defined in Listing 7.4, page135).
7: end for
8: In.Open // initialize all iterators recursively 9: repeat
10: µ:=In.GetNext
11: if µ6=EndOfFilethen reportµ endif
12: untilµ =EndOfFile
13: In.Close// close all iterators recursively
make up the complete (expected) query result for the example query over the example Web. However, other executions of the algorithm are also possible for the same example query (over the same example Web). Some of these (alternative) executions provide an incomplete query result only. In this section we discuss two of these executions, both of which reveal different characteristics of the iterator-based implementation approach.
We first focus on an execution that uses an alternative logical plan:
Example 7.3. For the query execution in Example 7.2 we assume a logical plan such that, in the corresponding physical plan, iteratorI1is responsible for triple patterntp1= (?product,producedBy,producer1) and I2 for tp2 = (?previous,oldVersionOf,?product); i.e., tp(I1) =tp1 and tp(I2) =tp2. Let us now use the alternative logical plan (Bex, /0ex) with tp2/0extp1. Hence, for the pipeline of iteratorsI00, I10, I20 that constitutes the corresponding (alternative) physical plan, it holds that tp(I10) =tp2 and tp(I20) =tp1.
The initialization of D by the root iterator is the same for all (iterator-based) ex-ecutions of the example query QBex,Sex. Hence, after the initialization, D consists of LD document dPr1 = adocex(producer1), because the corresponding set of seed URIs is Sex = {producer1} (cf. Example 7.2). The example execution proceeds as follows: Al-gorithm 7.5 calls the GetNext function of I20, this function calls GetNext of I10, and I10 consumes the empty valuation µ∅ from I00 (by callingGetNext of I00). Then, I10 tries to find matching triples for triple pattern µ∅tp(I10)= (?previous,oldVersionOf,?product) in the current snapshot of D (cf. line 8 in Listing 7.4, page 135). However, dataex(dPr1) does not contain such a triple (cf. Figure2.1, page19). Thus,I10 cannot return an inter-mediate solution to its successorI20. As a result, the query execution process terminates
with an incomplete (empty) query result. 2
7.2. Formal Analysis
Figure 7.3.: Sequence diagram for the query execution outlined in Example 7.4. Valu-ations and RDF triples mentioned in the diagram are the same as given in Figure 7.2(b)(cf. page 137).
The example verifies our claim that the iterator implementation of traversal-based query execution may produce an incomplete query result. Our experiments shall even show that there exist queries for whichnone of all possible logical plans produces the complete query result (cf. Section 7.3.3, page 158ff). Moreover, by comparing Example 7.3 and Example 7.2, we also note that for different logical plans, the approach may produce different subsets of the (complete) query result. Thus, in contrast to traditional query execution scenarios, alternative logical plans for this approach are not guaranteed to be semantically equivalent (nonetheless, each plan is sound). We come back to this limitation after interpreting the implementation approach in terms of our query execution model in the next section.
While the previous example uses a different logical plan, executions of Algorithm 7.5 may even differ without varying the logical (and, thus, physical) plan: We emphasize the arbitrary order in which iterators may report precomputed valuations (cf. lines 14to16 in Listing 7.4, page 135). Due to this flexibility we may observe different, nonidentical query execution processes for the same physical plan. This type of nondeterministic behavior is not unusual and has no consequences in the traditional, static case. It may however have an impact in the dynamic case as the following example demonstrates.
Example 7.4. Let the pipeline of iterators I0, I1, I2 be the same physical plan as in Example7.2(cf. page136). Hence, it holds that tp(I1) =tp1and tp(I2) =tp2. However, we now outline another possible execution of this physical plan. More precisely, we assume that iterator I1 reports the precomputed valuations Ωtmp(1) ={µ(1,1), µ(1,2)} in a different order than in Example 7.2. The sequence diagram in Figure 7.3 illustrates the execution process that we may observe in such a case.
Up to the point at which iterator I1 completes its expansion ofD(at line 12 in List-ing7.4, page135), the execution is identical to the execution in Example7.2. Hence, at
this point the currently discovered subwebDof the queried example Web Wex consists of the LD documentsdPr1,dp2, anddp3. Now, iteratorI1 returns precomputed valuation µ(1,2) to its successorI2 (in contrast to valuationµ(1,1) returned in Example7.2). Based on this valuation, iteratorI2 uses the current snapshot ofDto find matching triples for triple pattern µ(1,2)tp(I2) = (?previous,oldVersionOf,product3). Although such a match-ing triple exists in LD documentdp1 in the queried Web (cf. Example2.1, page18), this document has not been discovered and retrieved at this point. Therefore,I2 cannot con-struct valuationµ(2,2) as an augmentation ofµ(1,2) (as was possible during the execution in Example7.2). Instead,I2 discardsµ(1,2) and consumes the next valuation from I1.
The second valuation consumed from I1 isµ(1,1). Based on µ(1,1), iterator I2 tries to find matching triples for triple pattern µ(1,1)tp(I2) = (?previous,oldVersionOf,product2).
For this triple pattern the currently discovered subweb D already contains matching triple (product1,oldVersionOf,product2) (originating from LD document dp2). Hence,I2 con-structs (and returns) the corresponding valuation µ(2,1).
After that, the iterators return no more valuations and, thus, the execution outlined re-ports only valuationµ(2,1)as a solution of the query resultQBex,Sex(Wex) ={µ(2,1), µ(2,2)}.
Although this answer is not empty (as the answer produced by the execution in Exam-ple7.3), it is also not complete (in contrast to the answer in Example 7.2). 2 The example demonstrates that the nondeterministic order in which link traversing iter-ators report precomputed valuations may have an impact on the query results provided by a pipeline of such iterators. We emphasize, however, that the alternative report order used in Example 7.4(compared to the “original” order assumed in Example 7.2) is not the main reason for the incomplete query result reported by the execution. Instead, this alternative order merely allows us to observe the effect demonstrated in the example.
The actual reason why iterator I2 cannot compute valuation µ(2,2) in the example is that the iterators discard each input valuation after using it. While this “use and forget” strategy is typical for pipelined iterators, it presents a major limitation for our use case where it may lead to incomplete answers. On the other hand, due to this strategy the iterator implementation of traversal-based query execution has the following advantageous property as we shall see in the next section: It guarantees termination of query executions (even for queries that are not finitely computable by an LD machine).
Nonetheless, we may prevent the nondeterministic behavior of link traversing iterators by prescribing a particular (artificial) order in which iterators must report precomputed valuations. While such an adjustment does not address the issue of potentially incom-plete query results, it ensures repeatability. Consequently, for most of our experiments we shall use such an adjustment. However, for our formal results in the following section we take into account that multiple executions are possible for a physical plan.
7.2.2. Alignment of the Implementation with the Execution Model
We now show formally that (and how) Algorithm 7.5 implements our traversal-based query execution model (defined in Section6.3, page115ff). Thereafter, we use the result-ing propositions to prove Theorem 7.1 (cf. page 137). Furthermore, such an alignment
7.2. Formal Analysis shall allow us to provide a more informed explanation of the effects observed in the previous section. In the following, we first focus on the concept of partial solutions and then discuss the performance of open AE tasks by link traversing iterators.
In terms of our execution model, we may interpret each valuation computed and reported by a link traversing iterator as a partial solution (as introduced in Definition6.2, page116). The following proposition verifies this claim:
Proposition 7.1. Let QB,S be a CLD(M) query that uses a BGP B of size n = |B|;
let (B, /) be a logical plan for executing QB,S over a Web of Linked Data W; let the pipeline of link traversing iterators I0, ... , In be the corresponding physical plan; and let exec denote an execution of this physical plan. For anyk∈ {0, ... , n} and any valuation µ that iterator Ik computes and reports during exec it holds that the pair sub/k(B), µ is a partial solution forQB,S in W.
Proof. Let Ωexecall denote the set of all valuations that iterators I0 to In compute and report during exec. We prove Proposition 7.1 by induction on the sequence in which iterators I0 toIngenerate these valuations.
Base case: The first valuation generated by any of the iterators is the empty valuation µ∅ that root iteratorI0 generates. Since sub/0(B) =∅, the pair sub/0(B), µ∅is a partial solution for QB,S in W. In fact, this pair is the empty partial solution introduced on page117in Section6.3.2.
Induction step: Let µ(k,i) ∈ Ωexecall \ {µ∅} be an arbitrary valuation computed during exec after I0 generated µ∅. Furthermore, let Ik be the iterator that computes µ(k,i). We note that Ik cannot be the root iterator I0 because I0 generates no more valuations after generating µ∅ (as can be seen in Listings7.1 and 7.3). Let Ω denote the set of all valuations that all iteratorsI0 toInprecompute (duringexec) beforeIkcomputesµ(k,i). By induction we assume that for each valuation µ(k0,i0) ∈ Ω (where k0 ∈ {0, ... , n} and µ(k0,i0) is computed by iterator Ik0), the pair sub/k0(B), µ(k0,i0) is a partial solution for QB,S in W. Based on this hypothesis we show that the pair sub/k(B), µ(k,i) is also a partial solution for QB,S inW.
Letµ(k−1,j)be the valuation that iteratorIkconsumes from its predecessorIk−1during the particular execution of its GetNext function in which Ik (pre)computes µ(k,i). By induction, the pair sub/k(B), µ(k−1,j)is a partial solution for QB,S inW. Hereafter, we write σ(k−1,j) to denote this partial solution.
Let D(k−1,j) be the particular snapshot of Dthat Ik uses for generating µ(k,i). Since Ikcomputesµ(k,i)based onµ(k−1,j), there must exist an RDF triplet0 and a valuationµ0 such that (i)t0 ∈AllData(D(k−1,j)), (ii)µ(k,i)=µ(k−1,j)∪µ0, (iii) dom(µ0) = vars(tp0(k,j)), and (iv) t0 = µ0tp0(k,j), where tp0(k,j) = µ(k−1,j)
tp(Ik) (cf. line 9 in Listing 7.4, page135). Thus, for RDF triplet0 it also holds thatt0 =µ(k,i)tp(Ik).
Then, in terms of our execution model, the pair sub/k(B), µ(k,i)is the t0,tp(Ik) -aug-mentation of partial solution σ(k−1,j) (cf. Definition6.3, page 117). By Proposition6.4 (cf. page 117), this augmentation is a partial solution for QB,S inW if (i)σ(k−1,j) is a
partial solution for QB,S in W, and (ii) t0 ∈ AllData(R) where R is the (S, cMatch, B)-reachable subweb of W. Since the former holds by induction, it remains to prove the latter. Since t0 ∈AllData(D(k−1,j)), we provet0 ∈AllData(R) by showing that D(k−1,j) is a discovered subweb of R (in which case we have AllData(D(k−1,j))⊆AllData(R)).
After iterator I0 initialized Dwith Dinit(S,W), each (other) iterator from the pipeline may expand D only based on RDF triples that match the triple pattern for which the iterator is responsible (cf. lines 10 to 12 in Listing 7.4). Hence, snapshot D(k−1,j) is the result of expanding Dinit(S,W) using triples that match a triple pattern from BGP B. Since Dinit(S,W) is a discovered subweb of the (S, cMatch, B)-reachable subweb of W (cf. Definition6.5, page119), we use Lemma6.1 (cf. page123) recursively to show that D(k−1,j) is also a discovered subweb of the (S, cMatch, B)-reachable subweb ofW. Example 7.5. Revisiting the query execution discussed in Example7.2 (cf. page 136), we may say that iterator I1 implicitly generates partial solutionsσ(1,1) = {tp1}, µ(1,1) and σ(1,2) = {tp1}, µ(1,2). Similarly, iterator I2 (the other iterator in Example 7.2) generates partial solutionsσ(2,1) = {tp1, tp2}, µ(2,1)and σ(2,2) = {tp1, tp2}, µ(2,2). 2 Primarily, Proposition7.1shows that link traversing iterators (implicitly) generate par-tial solutions. However, the proposition also specifies these parpar-tial solutions. Thus, as a direct consequence of Proposition7.1 we highlight the following property:
Remark 7.1. LetI0, ... , Inbe a pipeline of link traversing iterators that executes logical plan (B, /) for CLD(M) query QB,S (where n = |B|). Then, for each k ∈ {0, ... , n}, iteratorIk is the only iterator from the pipeline that may (implicitly) generate a partial solution (E, µ)∈
σ
QB,S, W for which it holds thatE= sub/k(B) (whereσ
QB,S, W denotes the set of all partial solutions for QB,S over a queried Web of Linked DataW, as introduced in Definition6.2, page116).Remark 7.2. We also note that an iterator-based execution of a logical plan (B, /) for a CLD(M) queryQB,S cannot compute any partial solution (E, µ) ∈
σ
QB,S, Wfor which there does not exist ak∈ {0, ... ,|B|}such that E= sub/k(B).While Proposition 7.1 shows that link traversing iterators (implicitly) compute partial solutions, the following proposition shows that for each such iterator the overall number of these partial solutions is finite and there are not duplicates.
Proposition 7.2. Let (B, /) be a logical plan for executing a CLD(M) queryQB,S (over a Web of Linked Data), and let the pipeline of link traversing iterators I0, ... , In be the corresponding physical plan (where n=|B|). Any iterator in the physical plan computes and reports a finite number of valuations during any execution of the physical plan; each of these valuations is not compatible with any other valuation that the iterator computes during the execution. (We recall that two valuationsµandµ0 arenot compatible, denoted by µ6∼µ0, if there exists a variable ?v∈dom(µ)∩dom(µ0) such thatµ(?v)6=µ0(?v).) Proof. To prove Proposition 7.2 we assume (without loss of generality) a particular, arbitrary execution of the physical plan. The proof is by induction onk∈ {0, ... , n}.
7.2. Formal Analysis Base case (k= 0): Root iterator I0 reports a single valuation only (namely, the empty valuationµ∅); this happens only once (during any execution of the physical plan).
Induction step(1≤k≤n): Suppose iteratorIk−1 reports a finite number of valuations, each of which is not compatible with any other valuation that Ik−1 reports. If Ik−1
reports no valuations, thenIkcomputes no valuations and, thus, satisfies Proposition7.2.
Hence, in the remainder of this proof we assumeIk−1 reports at least a single valuation.
IteratorIk performs line 9in Listing7.4(cf. page135) as many times as iteratorIk−1
reports a valuation via its GetNext function. Each of these performances generates a new set Ωtmp. To denote the particular version of Ωtmp generated using the i-th input valuation (consumed from Ik−1) we write Ωtmp(k,i). By induction, there exists an upper bound m ∈ N+ for i (i.e., 0 < i ≤ m). Thus, to show that Ik computes a finite number of valuations only, it suffices to prove that Ωtmp(k,i)is finite for alli∈ {1, ... , m}:
Ik precomputes Ωtmp(k,i) using a snapshot of the currently discovered subweb of the queried Web of Linked Data. Since the set of LD documents in any discovered subweb is finite (cf. Definition6.4, page118), and the set of RDF triples in any LD document is also finite, we conclude that iteratorIk may only use a finite number of RDF triples to precompute Ωtmp(k,i). Thus, Ωtmp(k,i)is guaranteed to be finite. Removing any valuation µfrom the (current version of) set Ωtmp, before reporting this valuation, guarantees that the number of reported valuations is finite as well (cf. lines 14 to16in Listing7.4).
We now show that the valuations computed byIkare not compatible with one another.
We need to distinguish the following two cases:
1. We first focus on the difference of all valuations within any particular set Ωtmp(k,i) (for alli∈ {1, ... , m}): W.l.o.g., let Ωtmp(k,i) be such a set and letµ(k,x)∈Ωtmp(k,i) and µ(k,y)∈Ωtmp(k,i) be two of the valuations in this set; i.e.,µ(k,x) 6=µ(k,y). Fur-thermore, lettp0kbe the particular triple pattern that iteratorIkuses to precompute Ωtmp(k,i); i.e., tp0k=µ(k−1,i)
tp(Ik)whereµ(k−1,i) is thei-th input valuation (that Ik consumes from Ik−1). Then, there exist valuations µ0(k,x) and µ0(k,y) such that µ(k,x)=µ(k−1,i)∪µ0(k,x)andµ(k,y)=µ(k−1,i)∪µ0(k,y)(cf. line9in Listing7.4). These two valuations,µ0(k,x)andµ0(k,y), are computed from different matching triples (i.e., µ0(k,x)[tp0k] 6= µ0(k,y)[tp0k]), because µ(k,x) 6= µ(k,y). Therefore, µ0(k,x) 6∼ µ0(k,y) and, thus,µ(k,x)6∼µ(k,y).
2. It remains to show for any pair i, j ∈ {1, ... , m} with i 6= j that every valuation in Ωtmp(k,i) is incompatible with every valuation in Ωtmp(k,j). W.l.o.g., we use an arbitrary pair i, j ∈ {1, ... , m} such that i 6= j, and an arbitrary valuation µ(k,x) ∈Ωtmp(k,i). Then, valuation µ(k,x) consists of all variable bindings specified by the corresponding input valuation µ(k−1,i) Similarly, all valuations in Ωtmp(k,j) consist of all variable bindings from input valuation µ(k−1,j). Since i6=j, it holds by induction that µ(k−1,i) is not compatible with µ(k−1,j) and, thus, µ(k,x) is not compatible with any valuation in Ωtmp(k,j).
Given Propositions 7.1and 7.2, we are now ready to prove Theorem 7.1(cf. page 137):
Proof of Theorem 7.1. Let (B, /) be an arbitrary logical selected at the begin of executing CLD(M) query QB,S by Algorithm 7.5; let the pipeline of link traversing iter-ators I0, ... , In be the corresponding physical plan (where n = |B|); and let Ω be the set of all valuations that the last iterator,In, reports (via itsGetNext function) during an arbitrary execution of the physical plan. W.l.o.g., we may prove Theorem 7.1 by showing (i) Ω⊆ QB,S(W) and (ii) Ω is finite.
(i) To show Ω⊆ QB,S(W) it suffices to showµ∈ QB,S(W) for an arbitrary valuation µ ∈ Ω. Let µ∗ ∈ Ω be such a valuation. By Proposition 7.1, σ∗ = sub/n(B), µ∗ is a partial solution for QB,S in W. This partial solution covers the whole BGP B of QB,S because sub/n(B) = B. Therefore, we may use our definition of partial solutions (cf. Definition 6.2, page 116) and our definition of CLD(M) queries (cf. Definition 6.10, page123) to concludeµ∗∈ QB,S(W).
(ii) The finiteness of Ω is a direct consequence of Proposition 7.2.
While Propositions 7.1 and 7.2 suffice for proving Theorem 7.1, they cover only a sin-gle aspect of our execution model, namely, the computation of partial solutions. To verify that the iterator approach is an implementation of our query execution model it is also necessary to show that the approach performs open AE tasks. We recall that an AE task consists of a partial solution σ, a triple pattern tp, and an RDF triple t that matchestp (cf. Definition6.8, page122); performing such an AE task τ = (σ, t, tp) combines (i) generating a new partial solution by augmentingσ based ontand tp, and (ii) expanding the discovered subweb of the queried Web of Linked Data usingt(cf. Sec-tion 6.3.6, page 121ff). In the remainder of this section we argue that the execution of lines9to12in theGetNextfunction of link traversing iterators (cf. Listing7.4, page135) presents an (implicit) performance of open AE tasks.
Example 7.6. During the query executions discussed in Examples7.2and 7.4(cf. page 136 and 139, respectively), iterator I1 consumes the empty valuation µ∅ as an in-put valuation from its predecessor, root iterator I0. According to Proposition 7.1 (cf.
page141), we may say thatI1 consumes partial solution σinput = sub/0(B), µ∅, which, in this particular case, is the empty partial solution σ∅. By using this input, itera-tor I1 (implicitly) computes partial solutions σ(1,1) and σ(1,2) (as discussed in Exam-ple 7.5, page 142). In terms of our execution model we interpret this computation of σ(1,1) and σ(1,2) as a computation of all augmentations of partial solution σ∅ that are possible based on all matching triples for tp1 in the currently discovered subweb of the queried example Web Wex. For instance, σ(1,1) is the (t(1,1), tp1)-augmentation of σ∅ where t(1,1) denotes RDF triple (product2,producedBy,producer1) (cf. Figure 7.2(b), page 137). Similarly, σ(1,2) is the (t(1,2), tp1)-augmentation of σ∅ where t(1,2) denotes RDF triple (product3,producedBy,producer1). Immediately after augmenting σ∅ based on these two RDF triples (t(1,1) and t(1,2)), iterator I1 uses these triples for expanding the discovered subwebDtoEXP EXP D, t(1,1), Wex
, t(1,2), Wex
. Therefore, we may conclude that by executing lines9to12 of itsGetNextfunction, iterator I1 (implicitly) performs two AE tasks, namely τ(1,1)= (σ∅, t(1,1), tp1) andτ(1,2) = (σ∅, t(1,2), tp1). 2 The following result generalizes the conclusion from the example.
7.2. Formal Analysis Proposition 7.3. Let QB,S be a CLD(M) query that uses a BGP B of size n = |B|;
let (B, /) be a logical plan for executing QB,S over a Web of Linked Data W; let the pipeline of link traversing iterators I0, ... , In be the corresponding physical plan; and let exec denote a particular execution of this physical plan. Furthermore, let k∈ {1, ... , n};
let µinput be a valuation that iterator Ik consumes (from its predecessor Ik−1) during exec; let σinput = sub/k−1(B), µinput
; and let Dx denote the snapshot of the discovered subweb D of W immediately after Ik consumed µinput. During the particular execution of its GetNext function during which Ik consumes µinput, Ik performs the following set
τ
of open AE tasks:τ
=n σinput, t,tp(Ik)t∈AllData(Dx) is a matching triple for tp0k =µinput[tp(Ik)]o. Proof. In addition to the symbols introduced in Proposition 7.3, letgnexec denote the execution of the GetNext function during which Ik consumes µinput from Ik−1, and let Px be the set of partial solutions for QB,S in W such that the pair stx = Px,Dx represents the QE state of the query execution immediately after Ik consumes µinput, that is, beforeIk performs line8 duringgnexec (cf. Listing7.4, page 135). Similarly, let sty = Py,Dy be the QE state of the query execution immediately after Ik completes line 12 (in Listing7.4) during gnexec. Finally, let tp0k=µinput[tp(Ik)].To prove Proposition 7.3we have to prove the following claims:
1. Each τ ∈
τ
is an AE task forQB,S overW.2. Each AE taskτ ∈
τ
is not hidden in statestx. 3. Each AE taskτ ∈τ
is open in statestx.4. Each AE taskτ ∈
τ
is not open (anymore) in statesty.5. Any AE task τ0 for QB,S over W is (still) open in state sty if τ0 is open in state stx and τ0∈/
τ
.We notice that the fifth claim verifies that our specification of
τ
is complete while the first four claims verify the soundness of this specification.Before we prove these claims we need to specify statesstxand sty more accurately. In particular, we need to specify Px and Py. We recall thatPx and Py are the sets of all those partial solutions forQB,S inW that have already been computed up to the point in the query execution represented by state stx and sty, respectively. To specify these sets we emphasize that any pipeline of link traversing iterators may (implicitly) generate partial solutions only by precomputing valuations (cf. line 9in Listing 7.4). Hence,
Px=(sub/k0(B), µ)k0 ∈ {0, ... , n} and iteratorIk0 precomputes valuationµ before iteratorIk consumes µinput . By Proposition 7.1(cf. page 141), Px ⊆
σ
QB,S, W holds withσ
QB,S, W denoting the set of all partial solutions forQB,S overW (cf. Definition 6.2, page116).To specify Py we note that no other iterator, except for Ik, precomputes valuations while Ik executes lines8 to12 during gnexec. Thus,
Py =Px∪(sub/k(B), µ)µ∈Ωtmp(k,x) ,
where Ωtmp(k,x) denotes the particular version of set Ωtmp that Ik precomputes during gnexec. Based on lines8and 9 in Listing 7.4we have:
Ωtmp(k,x)=µinput∪µ0µ0 is a valuation with
dom(µ0) = vars(tp0k) andµ0[tp0k]∈AllData(Dy) . We now prove the aforementioned five claims in the following order: 5,1,2,4,3.
(5.) W.l.o.g., let AE taskτ = (σ, t, tp) with partial solutionσ = (E, µ) be an arbitrary AE task for CLD(M) query QB,S over Web of Linked Data W such that τ /∈
τ
and τ isopen in statestx. We prove by contradiction thatτ is also open in state sty; that is, we assumeτ is not open (anymore) in sty. In this case, by Definition6.12(cf. page125), it must hold that (i)τ is hidden instyor (ii)sty =τstx. However, since AE taskτ is open in statestx, it is not hidden instx(cf. Definition6.12) and, thus, it cannot be hidden in statesty(cf. Remark6.3, page124). Therefore, it must hold thatsty =τstxand, thus, the set of partial solutionsPy contains the (t, tp)-augmentation ofσ (cf. Definition 6.9,
open in statestx. We prove by contradiction thatτ is also open in state sty; that is, we assumeτ is not open (anymore) in sty. In this case, by Definition6.12(cf. page125), it must hold that (i)τ is hidden instyor (ii)sty =τstx. However, since AE taskτ is open in statestx, it is not hidden instx(cf. Definition6.12) and, thus, it cannot be hidden in statesty(cf. Remark6.3, page124). Therefore, it must hold thatsty =τstxand, thus, the set of partial solutionsPy contains the (t, tp)-augmentation ofσ (cf. Definition 6.9,