We address the problem of providing contextual information about a logical formula (e.g., provenance, date of validity, or con dence) and representing it within a logical system. In this case, it is needed to rely on a higher order or non standard formalism, or some kind of rei cation mechanism. We explore the case of rei cation and formalize the concept of contextualizing logical statements in the case of Description Logics. Then, we de ne several properties of contextualization that are desirable. No previous approaches satisfy all of the them. Consequently, we de ne a new way of contextually annotating statements. It is inspired by NdFluents, which is itself an extension of the 4dFluents approach for annotating statements with temporal context. In NdFluents, instances that are involved in a contextual statement are sliced into contextual parts, such that only parts in the same context hold relations to one another, with the goal of better preserving inferences. We generalize this idea by de ning contextual parts of relations and classes. This formal construction better satis es the properties, although not entirely. We show that it is a particular case of a general mechanism that NdFluents also instantiates, and present other variations.
The problem of being able to reason not only with logical formulas, but also about said formulas, is an old one in arti cial intelligence. McCarthy [1] proposed to extend rst order logic by reifying context and formulas to introduce a binary predicate ist( ; c) satis ed if the formula is true (ist) in the context c. However, a complete axiomatization and calculus for McCarthy's contextual logic has never been formalized. Giunchiglia [2] proposed the grouping of \local" formulas in contexts, and then using other kinds of formulas to characterize how knowledge from multiple contexts is compatible. This idea of locality+compatibility [3] has led to several non standard formalisms for reasoning with multiple contexts [4]. Alternatively, the approach of annotated logic programming [5] considers that a contextual annotation is just a value in an algebraic structure (e.g., a number or a temporal interval). This idea was later applied to annotated RDF and RDFS [6, 7].
The representation of statement annotation has sometimes being thought of as a data model problem without consideration of the logical formalism behind. In particular, several proposals to extend the RDF data model in various ways for allowing annotations have been made: named graphs [8], RDF+ [9], RDF* [10], Yago Model [11]. However, the underlying data structures have not a clear formal semantics. Therefore, some authors advocate another approach to representing annotation of knowledge: reify the statement or its context and describe it within the formalism of the statement. This requires modifying the statement so as to integrate knowledge of the context or statement. Examples of such techniques are rei cation [12], N-Ary Relations [13], Singleton Property [14]), and NdFluents [15]. This paper provides an abstraction of the rei cation techniques in the context of Description Logics (DLs) in the form of what we call contextualization functions. Additionally, we introduce a new technique for the representation of contextual annotations that satis es better some desirable properties.
After introducing our notations for DLs in Sec. 2, we provide formal de nitions that allow us to de ne veri able properties of the rei cation techniques (Sec. 3). Our new technique, named NdTerms, is presented in Sec. 4, where we also prove to what extent it satis es the properties of the previous section. Sec. 5 discuss some of the problems that may occur when combining knowledge having di erent annotations. In Sec. 6, we present how the other approaches t in our formalization and why they do not satisfy well the properties. Finally, we discuss this and future work in Sec. 7. 2
In this section, we introduce the notations and de nitions we use in relation to Description Logics. Note that we use an extended version of DL where all terms can be used as concept names, role names, and individual names in the same ontology. Using the same name for di erent types of terms is known as \punning" in OWL 2 [16, Section 2.4.1]. Moreover, we allow more constructs than in OWL 2 DL and make no restriction on their use in order to show that our approach is not limited to a speci c DL.
We assume that there is an in nite set of terms N. Every term is an individual. A role is either a term or, given roles R and S, R t S, R u S, :R, R , R S and R+. A concept is either a term, or, given concepts C, D, role R, individuals u1; : : : ; uk, and natural number n, ?, >, C t D, C u D, 9R:C, 8R:C, nR:C, nR:C, :C or fu1; : : : ; ukg. Finally, we also allow concept product C D to de ne a role.
Interpretations are tuples h I ; Iu ; Ir ; Ic i, where I is a non-empty set (the domain of interpretation) and Iu , Ir , and Ic are the interpretation functions for individuals, roles and concepts respectively such that: { for all u 2 N, uIu 2 I ; { for all P 2 N, P Ir I I and interpretation of roles is inductively de ned by (R t S)Ir = RIr [ SIr , (R u S)Ir = RIr \ SIr , (:R)Ir = ( I I )nRIr , (R )Ir = fhx; yijhy; xi 2 RIr g, (R S)Ir = fhx; yij9z:hx; zi 2 RIr ^ hz; yi 2 SIr g and (R+)Ir is the re exive-transitive closure of RIr (with R and S being arbitrary roles). { for all A 2 N, AIc I and interpretation of concepts is de ned by ?Ic = ;, >Ic = I , (C t D)Ic = CIc [ DIc , (C u D)Ic = CIc \ DIc , (9R:C)Ic = fxj9y:y 2 CIc ^ hx; yi 2 RIr g, (8R:C)Ic = fxj8y:hx; yi 2 RIr ) y 2 CIc g, ( nR:C)Ic = fxj]fy 2 CIc jhx; yi 2 RIr g ng, ( nR:C)Ic = fxj]fy 2 CIc jhx; yi 2 RIr g ng, (:C)Ic = I n CIc , fu1; : : : ; ukg = fu1Iu ; : : : ; ukIu g, where C and D are arbitrary concepts, R an arbitrary role, u1; : : : ; uk are individual names, and k and n two natural numbers. { Roles de ned as a concept product are interpreted as (C D)Ir = CIc DIc for arbitrary concepts C and D.
In the following, we slightly abuse notations by de ning interpretations as pairs h I ; I i where I denotes the three functions Iu , Ic , and Ir . Moreover, when we write xI = yI0 , it means \xIu = yIu0 and xIc = yIc0 and xIr = yIr0 ".
Axioms are either general concept inclusions C vc D, sub-role axioms R vr S, instance assertions C(a), or role assertions R(a; b), where C and D are concepts, R and S are roles, and a and b are individual names. An interpretation I satis es axiom C vc D i CIc DIc ; it satis es R vr S i RIr SIr ; it satis es C(a) i aIu 2 CIc ; and it satis es R(a; b) i haIu ; bIu i 2 RIr . When I satis es an axiom , it is denoted by I j= . Instance assertions, role assertions and individual identities constitute the ABox axioms.
An ontology O is composed of a set of terms called the signature of O and denoted by Sig(O), and a set of axioms denoted by Ax(O). An interpretation I is a model of an ontology O i for all 2 Ax(O), I j= . In this case, we write I j= O. The set of all models of an ontology O is denoted by Mod(O). A semantic consequence of an ontology O is a formula such that for all I 2 Mod(O), I j= .
In the rest of the paper, we will use teletype font to denote known individuals, and normal font for unknown individuals and variables (e.g., City(babylon) and City(x)). 3
A contextual annotation can be thought of as a set of ABox axioms that describe an individual representing the statement (the anchor) that is annotated. An annotated statement (or ontology) is the combination of a DL axiom (or DL ontology) with a contextual annotation.
De nition 1 (Connected individuals). Two terms a and b are connected individuals wrt an ABox A i a and b are used as individual names in A, and either { a and b are the same term, or { there exists R1; ; Rn and z1;
R1(a; z1), or R1(z1; a) Ri(zi 1; zi), or Ri(zi; zi 1), 2 Rn(zn 1; b), or Rn(b; zn 1) ; zn 1, such that: i Example 1. If we consider the ABox A = fP (a; b); Q(c; b); S(d; e)g, the pairs of individuals fa; bg, fb; cg, fa; cg, and fd; eg are connected individuals, but fa; dg, fb; dg, fc; dg, fa; eg, fb; eg, and fc; eg are not.
De nition 2 (Contextual annotation). A contextual annotation Ca is an ABox with signature fag [ where a 62 is a distinguished term (called the anchor) and is a DL signature such that 8x 2 , fa; xg are connected individuals.
Example 2. The Abox CA = fvalidity(a; t); Interval(t) from(t; 609BC); to(t; 539BC), prov(a; w); name(w; wikipedia); Wiki(w)g is a contextual annotation, where a is the anchor and = ft; Interval; w; wikipedia; wiki; 609BC; 539BCg. De nition 3 (Annotated statement). An annotated statement is a pair h ; Cai such that is a description logic axiom and Ca is a contextual annotation.
Example 3. The pair h ; CAi, where = capital(babylon; babylonianEmpire) and CA is the contextual annotation from Ex. 2, is an annotated statement. De nition 4 (Annotated ontology). An annotated ontology is a pair hO; Cai such that O is a description logic ontology and Ca is a contextual annotation.
Each rei cation technique has an implicit construction plan in order to map an annotated statement to a resulting ontology. A contextualization (Def. 5) represents the procedure that generates a single DL ontology from a given annotated statement or ontology. The procedure must not lose information, especially not the annotation.
De nition 5 (Contextualization). A contextualization is a function f that maps each annotated statement Ca = h ; Cai to a description logic ontology f ( Ca ) = St( Ca ) [ Cx( Ca ) such that: { there exists an individual u in the signature of St( Ca ) and of Cx( Ca ) such that: for all R(a; x) 2 Ca, R(u; x) 2 Cx( Ca ); for all R(x; a) 2 Ca, R(x; u) 2 Cx( Ca ); for all C(a) 2 Ca, C(u) 2 Cx( Ca ); for all other 2 Ca, 2 Cx( Ca ). { there is an injective mapping between the signature of and the signature of St( C ).
We extend f to all annotated ontologies OCa = hO; Cai by de ning f (OCa ) = S 2O f (h ; Cai).
Example 4. An example contextualization function fex introduces a fresh term t for each annotated statement with a role assertion R(a; b), where R, a, and b are three therms, creates new axioms subject(t; s), predicate(t; R), object(t; o), and nally removes the axiom R(a; b). Notice that this construction requires the punning of term R. This function is analogous to RDF Rei cation. The result of this contextualization, along with Other possible known approaches, is described in Sec. 6.
Those are the only structures that we will consider in this paper. The remaining de nitions are desirable properties that a contextualization should satisfy, especially if one wants it to preserve as much of the original knowledge as possible.
De nition 6 (Soundness). A contextualization function f is sound wrt a set of annotated ontologies i for each OCa = hO; Cai 2 such that O and Ca are consistent, then f (OCa ) is consistent.
That is, a contextualization is sound if, when contextualizing a consistent ontology, the result is also consistent. This property avoids that the contextualization introduces unnecessary contradictions that would result in everything being entailed by it. Note that this requirement is not necessary in the opposite direction, i.e., if f (OCa ) is consistent, it is not required that O and C are consistent.
Example 5. The contextualization function fex from Ex. 4 is sound wrt the set of ontologies , where [ fsubject; predicate; predicateg = ;.
De nition 7 (Inconsistency preservation). Let f be a contextualization function. We say that f preserves inconsistencies i for all annotated ontologies OCa = hO; Cai, if O is inconsistent then f (OCa ) is inconsistent.
Inconsistency preservation means that a self-contradictory ontology in a given context is contextualized into an inconsistent ontology, such that bringing additional knowledge from other contexts would result in no more consistency. If something is inconsistent within a context, then it is not really worth to consider reasoning with this annotated ontology.
Example 6. The contextualization function fex from Ex. 4 does not preserve inconsistencies. For instance, capitalOf can be de ned as irre exive using the following axiom: 9capitalOf:> v 8capitalOf :?. Then, the axiom capitalOf(babylon; babylon) would make the ontology inconsistent. But when applying fex the result is consistent.
De nition 8 (Entailment preservation). Let f be a contextualization function. Given two description logic ontologies O1 and O2 such that O1 j= O2, we say that f preserves the entailment between O1 and O2 i for all contextual annotations Ca, f (hO1; Cai) j= f (hO2; Cai). Given a set K Na of contextual annotations, if f preserves all entailments between ontologies in K, then we say that f is entailment preserving for K.
In short, a contextualization is entailment preserving if all the knowledge that could be inferred from the original ontology can also be inferred, in the same context, in the contextualized ontology.
Example 7. The contextualization function fex from Ex. 4 preserves entailments for the TBox of ontologies (because no modi cations are made on its axioms), but it does not preserve entailments on role assertions. For instance, the axioms capitalOf v cityOf, capitalOf(babylon; babylonianEmpire) entails cityOf(babylon; babylonianEmpire), but this inference is not preserved after applying fex. 4
This section de nes the NdTerms approach that extends the NdFluent proposal [15]. To this end, we assume that terms are divided into three in nite disjoint sets Nnc, Nc, and Na called the non contextual terms, the contextual terms, and the anchor terms respectively. We also assume that there is an injective function A : C ! Na and for all Ca 2 C there is an injective function renCa : Nnc ! Nc and two terms isContextualPartOf; isInContext 2 Nnc. For any Ca, we extend renCa to axioms by de ning renCa ( ) as the axiom built from by replacing all terms t 2 Sig( ) with renCa (t). The contextualization needs to combine the ontologies from the statements and the contextual annotation. However, if we navely make the union of the axioms, they could contradict, and it would not be possible to ensure the desired properties. For example, an ontology may restrict the size of the domain of interpretation to be of a xed cardinality, while the contextual annotation may rely on more elements outside the local universe of this context. For this reason we use the concept or relativization: The ontology is modi ed in such a way that the interpretation of everything explicitly described in it is con ned to a set, while external terms or constructs may have elements outside said set. Relativization has been applied in various logical settings over the past four decades (e.g., [17]) and applied to DLs and OWL [18], among others.
De nition 9 (Relativization). Let Ca be a contextual annotation. Given an ontology O, the relativization of O in Ca is an ontology RelCa (O) built from O as follows: 1. Sig(RelCa (O)) = Sig(O) [ >Ca where >Ca is a term not appearing in Sig(O); 2. for all appearances of > in an axiom of O, replace > with >Ca ; 3. for all concepts :C appearing in an axiom of O, replace it with :C u >Ca ; 4. for all roles :R appearing in an axiom of O, replace it with :Ru(>Ca >Ca ); 5. for all concepts 8R:C appearing in an axiom of O, replace it with 8R:C u>Ca ; 6. for all roles R+ appearing in an axiom of O, replace it with R+ u >Ca >Ca . 7. Additionally, for all terms t 2 Sig(O), the following axioms are in RelCa (O): { t v >Ca , { >Ca (t), { 9t:> v >Ca , { > v 8t:>Ca .
The relativization of an ontology can be done systematically by relativizing its concepts and roles, which in turn can be achieved by using Def. 10.
De nition 10 (Relativization of concepts and roles). Given a contextual annotation Ca, we de ne a function relCa that maps concepts and roles to concepts and roles according to the rules of Items 2-6. That is, recursively: { relCa (t) = t; { relCa (fu1; : : : ukg) = frelCa (u1); : : : relf (uk)g; { relCa (C t D) = relCa (C) t relCa (D); { relCa (C u D) = relCa (C) u relCa (D); { relCa (:C) = :relCa (C) u >Ca ; { relCa (C D) = relCa (C) relCa (D); { relCa (R t S) = relCa (R) t relCa (S); { relCa (R u S) = relCa (R) u relCa (S); { relCa (R S) = relCa (R) relCa (S); { relCa (:R) = :relCa (R) u >Ca >Ca ; { relCa (R ) = relCa (R) ; { relCa (R+) = relCa (R)+ u >Ca >Ca ; { relCa (9R:C) = 9relCa (R):relCa (C); { relCa (8R:C) = 8relCa (R):relCa (C) u >Ca ; { relCa ( nR:C) = n relCa (R):relCa (C); { relCa ( nR:C) = n relCa (R):relCa (C). where t is a term, C; D are concepts, R; S are roles, u1; : : : uk are individuals, and k; n are natural numbers.
Example 8. The axiom 9capitalOf:> v 8capitalOf :? from Ex. 6 is relativized into 9capitalOf:>Ca v 8capitalOf :? u >Ca .
Then, the contextualization in NdTerms is done by: (
De nition 11 (Contextualization in NdTerms). Let Ca 2 C be any contextual annotation. Let Ca = h ; Cai be an annotated statement such that the signatures of and Ca are in Nnc. We de ne the contextualization function fnd such that fnd( Ca ) = St( Ca ) [ Cx(Ca) and: { StCa ( ) = frenCa (RelCa ( ))g[fisContextualPartOf(renCa (t); t) j t 2 Sig( )g[ fisInContext(renCa (t); A(Ca)) j t 2 Sig( )g. { Cx(Ca) contains exactly the following axioms: for all R(a; x) 2 Ca, R(A(Ca); x) 2 Cx( ); for all R(x; a) 2 Ca, R(x; A(Ca)) 2 Cx(Ca); for all C(a) 2 Ca, C(A(Ca)) 2 Cx(Ca); for all other axioms 2 Ca, 2 Cx(Ca).
Similarly to Ex. 4, this construction requires punning, since all terms in the statement are used as individual names in the role assertion isContextualPartOf(renCa (t); t).
Example 9. The NdTerms contextualization of our running example within the context CA of Ex. 2 contains the following axioms, where term@Ca is the result of the renaming function renCa (term): capitalOf@CA(babylon@CA; babylonianEmpire@CA) isContextualPartOf(babylon@CA; babylon) isContextualPartOf(babylonianEmpire@CA; babylonianEmpire) isInContext(babylon; exampleContext) isInContext(babylonianEmpire; exampleContext) validity(exampleContext; t) etc. This subsection presents the properties satis ed by NdTerms. Due to space constraints, we omit the proofs of the theorems, but they are provided in the accompanying technical report [19].
The contextualization of NdTerms is sound, but only wrt annotated ontologies that satisfy certain conditions. In order to present the conditions, we need to introduce the following de nition, that is also used in several proofs of this paper.
De nition 12 (Domain extensibility). Let O be an ontology. A model I = h I ; I i of O is domain extensible for O i for all sets +, I0 = h I [ +; I i is also a model of O. An ontology is said to be model extensible i it has a model that is domain extensible.
Note that, even if the domain of interpretation of an ontology is in nite, that does not necessarily mean that its models are domain extensible. This notion is closely related to the notion of expansion in [18] since if I is domain extensible, then one can build in nitely many expansions of it.
Theorem 1 (Soundness of NdTerms). Let Ca be a contextual annotation. If Ca has its signature in Nnc and is model extensible, then the contextualization function fnd is sound wrt annotated ontologies OCa = hO; Cai, Sig(O) Nnc, and Sig(O) \ Sig(Ca) = ;.
A model of the union of the of two ontologies can be made from the union of the models of the original ontologies if both ontologies are domain extensible. However, this is not a strong restriction, because the relativization of any consistent ontology is model extensible. Since NdTerms relativizes the ontology O and requires the contextual annotation Ca to be model extensible, it follows that a model can be made. Hence NdTerms is sound.
Theorem 2 (Inconsistency preservation of NdTerms). The contextualization function fnd preserves inconsistencies.
If the contextualization of an ontology fnd(OCa ) is consistent, then the original ontology O is necessarily consistent. Because the renaming function renCa is injective, there exists an inverse function renCa : renCa (Nnc) ! Nnc which is itself injective, and the renaming of terms gives us a model. The relativization function relCa , on the other hand, does not change the interpretation (since >I00 = >ICa00 , adding u>Ca to a concept does not change its interpretation, and replacing > with >Ca has no e ect on the interpretation of the concepts or roles). Therefore, if a model satis es the contextualization function fnd(OCa ), it also satis es O, and it is not possible to have a consistent NdTerms contextualization of a non-consistent ontology.
In [15], we were only able to study entailment preservation in the limited setting of pD entailment. Here we present a much stronger theorem for NdTerms . Theorem 3 (Entailment preservation of NdTerms). Let Ca be a contextual annotation, let be a set of ontologies having their signatures in Nnc and disjoint from the signature of Ca. If Ca is model extensible, then NdTerms is entailment preserving for fhO; CaigO2 .
If the ontology O is inconsistent, the entailment is trivially preserved. If not, considering that the relativization of a consistent ontology preserves entailments, and that the function renCa is just a renaming (and \truth is invariant under change of notation" [20]), the entailments of the ontology O are preserved. Moreover, all axioms in Cx(Ca) are satis ed by the interpretation I, and whenever isContextualPartOf(renKa ; t) or isInContext(renKa (t); A(Ka)) are in the entailed contextualized ontology, then they are in original as well as well. Therefore, all entailments are preserved, and NdTerms satis es this property. 5
So far, we assumed that all axioms of an ontology are annotated with the same contextual information. In this setting, the core of the contextualization function in NdTerms amounts to relativizing the axioms and renaming the terms. The renaming part may seem surprising because, as we said a couple of times already, \truth is invariant under change of notation". However, the usefulness of the renaming part becomes apparent when we want to combine several annotated ontologies having di erent contextual annotations (say Ca1 and Ca2). In this case, if the renaming functions renCa1 and renCa2 are mapping non contextual terms into disjoint sets of contextual terms, then the contextualization function fnd ensures that any inference made in a context will not interact with the knowledge from another context. This avoids the contextualized knowledge to be inconsistent when combining statements in di erent contexts that contradict each others.
The properties presented in Sec. 3 require a little adaptation when applied to the multi-contextual setting. Indeed, in spite of the soundness theorem of Sec. 4.2, in the general case if a set of annotated ontologies fhOi; Caiigi2I are satisfying the constraints of Theorem 1, it is still possible that Si2I fnd(hOi; Caii) is inconsistent. We expect that the preservation of consistency can be guaranteed if all the signatures of fOig are disjoint from all the signatures of fCaig. Studying in more details the case of multiple contextual annotations is planned for future work. 6
Here we brie y present the most relevant rei cation approaches in the Semantic Web. For all of them, the contextualization only annotates the role assertions, leaving other axioms unmodi ed.
As seen in Ex. 4, RDF rei cation replaces = R(x; y) with three new role assertions subject(aCa ; x), predicate(aCa ; R), and object(aCa ; y) and the axioms in the contextual annotation are anchored on aCa , which depends on the role assertion R and the contextual annotation Ca. As shown in Ex. 6 and 7, this contextualization method preserves neither inconsistencies (in the sense of Def. 7) nor entailments on role assertions.
Example 10. An RDF rei cation contextualization of our running example within the context CA of Ex. 2 contains the following axioms: subject(stbcobe; babylon) predicate(stbcobe; capital) object(stbcobe; babylonianEmpire) validity(stbcobe; t) etc.
N-Ary relations replaces R(x; y) by two role assertions p1(R)(x; aCa ) and p2(R)(aCa ; y), where R is a simple role assertion, and p1 and p2 are two injective functions with disjoint ranges that map non-contextual roles to contextual roles. Alternatively, a new concept CR is added for the role R, and the following assertions are added: CR(aCa ), p1(R)(aCa ; x), and p2(R)(aCa ; y). Example 11. An N-Ary relations contextualization of our running example within the context CA of Ex. 2 contains the following axioms: capitalOf#1(babylon; rbcobe) capitalOf#2(rbcobe; babylonianEmpire) validity(rbcobe; t) etc.
Singleton property is using a non-standard semantics of RDF but the same idea can be simulated with DL axioms. For each simple role axiom R(x; y), the following axioms are added: aCa (x; y) (that is, the term for the anchor is used as a role), fxg 9aCa :fyg (which guarantees that the anchor property is a singleton), and singletonPropertyOf(aCa ; R).
Example 12. A Singleton Property contextualization of our running example within the context CA of Ex. 2 contains the following axioms: capital#1(babylon; babylonianEmpire) singletonPropertyOf(capital#1; capital) validity(capital#1; t) etc.
The remaining approach, NdFluents, uses a similar approach as NdTerms except that it only renames the terms used as individuals and does not relativize the ontology. This ensures interesting properties wrt entailment preservation [15], but TBox axioms in di erent contexts are not distinguishable. 7
NdTerms and NdFluents are a concrete instantiations of a general approach of contextualizing (parts of) the terms in the ontology. Other instantiations would be possible, such as contextualizing role names (in a similar fashion as the singleton property), class names, or a combination of them. Then, NdTerms would be the approach where each and every term is contextualized, while in NdFluents only individuals are.
In the future, we would like to deepen the analysis of contextualization, lling gaps still present in this preliminary work. Especially, the combination of multiple annotations, or annotations of contextualized ontologies, present some interesting challenges. A more systematic comparison of the various approaches remains to be presented.
Acknowledgement: This work was partly funded by project WDAqua
(H2020MSCA-ITN-2014 #64279) and project OpenSensingCity (ANR-14-CE24-0029).
5. Kifer, M., Subrahmanian, V.S.: Theory of generalized annotated logic
programming and its applications. Journal of Logic Programming 12(3&4) (1992) 335{367
6. Udrea, O., Recupero, D.R., Subrahmanian, V.S.: Annotated RDF. ACM
Transaction on Computational Logics 11(
In Ellis, A., Hagino, T., eds.: Proceedings of the 14th International Conference on
World Wide Web, WWW 2005, Chiba, Japan, May 10-14, 2005, ACM Press (May
2007) 613{622
9. Dividino, R.Q., Sizof, S., Staab, S., Schueler, B.: Querying for provenance, trust,
uncertainty and other meta knowledge in RDF. Journal of Web Semantics 7(
Logics. Technical report, Laboratoire Hubert Curien, Saint-Etienne, France (2017)
20. Goguen, J.A., Burstall, R.M.: Institutions: Abstract Model Theory for Speci
cation and Programming. Journal of the ACM 39(