Welcome to RDF Surfaces

Hello all,


Welcome to the RDF Surfaces Community Group. The aim of this group is to bring together people that have interest in implementing, specifying and experimenting with RDF Surfaces ( also called BLOGIC) as envisioned by Pat Hayes in his 2009 ISWC Invited Talk https://www.slideshare.net/PatHayes/blogic-iswc-2009-invited-talk.


RDF Surfaces adds the semantics to RDF to define surfaces (boundaries) around RDF graphs which can assert all triples within a surface true, false, neutral, or any other user defined semantics. Reasoners operating with data on RDF surfaces have a natural boundary over which they can safely reason. Combining a boundary, the standard conjunction that is available in RDF logic and a classical negation all classical logical operators AND, OR, NOT, IMPLIES can be implemented. Within a boundary reasoners can safely execute non-monotonic queries (e.g. not-exist queries).


RDF Surfaces keeps the semantic meaning of blank nodes as existential quantifiers, but disallows copying blank nodes from one RDF Surface to another. Blank nodes are treated as local graffiti on an RDF Surface. With a negative surface, blank node existential quantifiers can be turned into universal quantifiers and vice versa using De Morgan's duality.


Blank nodes as existential quantifiers, plus all classical logical operators, provides the possibility to allow all of first-order logic in a language.. How this will turn out in reality in real applications is an open question.


At this stage of our project we have implemented RDF Surfaces in Notation3 because of various reasons:


  *   The N3 syntax allows for a natural grouping of RDF Graphs in the form of formulas (everything between curly brackets { })

  *   The N3 syntax has an extensive list of built-in functions and relations that are readily available to extend first-order logic with real programming capabilities

  *   The N3 syntax is on its way to standardization with is already supported by many parsers

  *   RDF Surfaces can be implemented in N3 as just another built-in (currently as a log:onNegativeSurface)

  *   Inference fuses can be safely and automatically blown at runtime when an empty negative surface is inferred

  *   The first implementation of RDF Surfaces in the EYE reasoner (https://github.com/eyereasoner/eye) could piggy-back on the existing code base and the first implementations only required a few additions to add negation to the reasoner


We have an interest in bringing reasoning to browsers and N3 reasoning is core to that. We don't expect many users will directly write RDF Surfaces scripts, but we do expect that first-order capabilities can be compiled into RDF Surfaces.


Reasoning in web browsers adds new security concerns. In order to allow reasoning scripts from third parties to run in a browser one must define the misuse of information and express what should in no circumstance happen to the data in the context of the browser.


This same misuse argument can also be made for Solid project use cases where we are also involved in. If we want to allow for reasoning executed very close in the security environment of a Solid pod we need to know what kind of information must not be shared with the rest of the world due to privacy or GDPR concerns. With RDF Surfaces it is possible to define RDF policies that can express use and misuse of data.


There have been other use-case cases already mentioned in discussion we had over the last weeks:


  *   Reasoning on RDF streams: reasoning over a window (time based surface) of triples

  *   Deprecated RDF data

  *   Quality control on data and validation

  *   Other logics such as fuzzy logics (as surface that expresses a painting that maybe contains Mona Lisa)


Our RDF primer is now available at: https://w3c-cg.github.io/rdfsurfaces/

The community group is at: https://www.w3.org/community/rdfsurfaces/

Issues , bug, questions can be posted also in as GitHub issues: https://github.com/w3c-cg/rdfsurfaces


The first things we need to figure out as the issues around what features of first-order logic can be implemented in reasoners. How much processing power is required to do that (so that we know the impact of reasoning on browsers or reasoning service providers). We also want to create some examples for the different use-cases to experiment with the language and see what works and what not. There are also concerns about the syntax and the differences in scoping of blank nodes in N3 and RDF Surfaces. The discussion on which built-ins need to be part of the core of N3 is quite important for us and which effect they have on reasoning. We certainly want to help new implementers in their experiments.


We hope working together for a bright future for N3 and RDF Surfaces.


BR

Patrick & Jos