CS 6795 Semantic Web Techniques

Fall 2012 Projects

 

The projects develop and/or apply Semantic Web tools in domains of knowledge based on the students’ interests. The prototypes described here have been created to study Semantic Web techniques and are not intended to provide any domain-oriented recommendation.

 

Syllabus
Assigns
Notes
Labs
Project
Resources

Advisor(s)

Topics and Homepages of Teams

Abstracts and URL Starting Points

Harold Boley

Team 1 A Grailog Visualizer for Datalog RuleML via XSLT 2.0 Translation to SVG

Sven Schmidt,

Martin Koch

 

Datalog is the core of deductive-database and logic-programming formalisms. It can be interchanged, using XML, with Datalog RuleML (cf. RuleML Primer). Its symbolic facts, queries, and rules can be visualized with Grailog (cf. Grailog Slides). The mapping between Datalog visualizations in a Grailog subset and their symbolic counterparts in RuleML/XML has been shown in the Grailog Slides.

The project will represent this subset of Grailog in a subset of the Scalable Vector Graphics (SVG), again using XML. Then a mapping from RuleML/XML to SVG/XML will be defined, using XSLT 2.0, for translating each Datalog RuleML/XML fact, query, and (as resources permits) rule, one at a time, to SVG/XML for rendering. So no ‘merging’ of box copies or other complex layouting will be needed in SVG/XML for this initial version. Basically, Datalog’s n-ary relationships will be translated to Grailog’s directed hyperarc arrows connecting its argument-box nodes. The arrows may be represented as SVG paths/lines/polylines, with arrowhead markers; the nodes as rectangle variants. This will allow an initial Grailog visualization of Datalog RuleML knowledge bases and queries in a ‘fully node copied’ normal form, where the separation of clauses of the symbolic form is kept in the graphic form.

The Grailog visualizer will be made available on the Web, open source, so it can be pointed to from the RuleML and Grailog sites.

 

RuleML Primer: http://ruleml.org/papers/Primer

 

Grailog Slides: http://www.cs.unb.ca/~boley/talks/RuleMLGrailog.pdf

 

SVG (tutorial): http://www.w3schools.com/svg/svg_intro.asp

SVG (spec): http://www.w3.org/TR/SVG/

 

XSLT 2.0 (spec): http://www.w3.org/TR/xslt20/

 

Alexandre Riazanov,

Harold Boley

Team 2 An Object-Relational Core Decision Support System: Specification in PSOA RuleML and Testing in PSOATransRun

XYZ

 

In F-logic and RIF, objects (frames) are defined entirely separately from function and predicate applications. In POSL and RuleML, these fundamental notions are integrated by permitting applications with optional object identifiers and, orthogonally, arguments that are positional or slotted. The resulting positional-slotted, object-applicative (psoa) terms were given a novel formalization, reducing the number of RIF terms by generalizing its positional and slotted (named-argument) terms as well as its frame terms and class memberships. Like multi-slot frames accommodate for (Web-)distributed slotted descriptions of the same object identifier (IRI), multi-tuple psoa terms (e.g., shelves) do for positional descriptions. The syntax and semantics of these integrated terms and rules over them are defined as PSOA RuleML in the style of RIF-BLD. Positional-slotted, object-applicative (psoa) terms generalize and integrate W3C RIF’s F-logic-like positional and slotted (named-argument) terms as well as its frame terms and class memberships.

The project will use the PSOA RuleML implementation called PSOATransRun to model an excerpt of a domain of knowledge in an object-relational fashion using frames, shelves, OID-anchored positional facts, and their combinations, as well as decision rules over them. Earlier Web-published POSL fact and rule bases such as NBBizKB, ChemXelem, FindXpRT,  eTourPlan (POSL Knowledge Bases), and the Personal Agents of Rule Responder instantiations such as WellnessRules (Rule Responder) can act as modeling examples in a similar formalism. The knowledge domain must be amenable to the expressivity of the current PSOA RuleML implementation and should be within (at least) one of the project members’ area of expertise (e.g., in health/wellness/sports, environment/climate, sciences/engineering, or humanities/culture). The domain specification will focus on the use of PSOA RuleML facts. On top of this, a core decision support system for the chosen domain will be developed in PSOA RuleML. Its modeling will focus on the use of PSOA RuleML rules. Decisions will involve search through a space of solutions defined by the rules. Domain facts and decision rules will be tested individually and in combination by posing queries to PSOATransRun.

The core decision support system will be made available on the Web, open source, so it can be pointed to from the PSOA RuleML site.

 

PSOA RuleML / PSOATransRun (with various examples and links):
http://wiki.ruleml.org/index.php/PSOA_RuleML#PSOATransRun

 

POSL Knowledge Bases: http://ruleml.org/#Library

 

Rule Responder: http://ruleml.org/RuleResponder/

 

Tara Athan,

Harold Boley

Team 3 A Test Case Suite for Derivation RuleML

XYZ

 

Side by side with Reaction RuleML, Deliberation RuleML comprises a family of sublanguages, starting with Datalog, Hornlog, and other Derivation Rules, and proceeding to FOL and beyond. Collections of test and use cases have been developed across RuleML versions for various purposes, including for validation, transformation, and execution.

The current examples of rulebases (including test queries) in Derivation RuleML up to Naf Hornlog shall be developed for and completed to a comprehensive Test Case Suite, thus enabling interoperability and benchmarking. In the spirit of RuleML 1.0 being a ‘Rosetta Stone’ release, these RuleML 1.0 instance documents shall be formatted in an easy-to-read standard (pretty-print-indented) manner. Like the RuleML 1.0 Examples, they should have a prelude such that they can be validated in both XML Schema and Relax NG. Hence they shall be double-validated with XSV (XML Schema) and Validator.nu (Relax NG). Alignment with W3C RIF (Core and BLD) Test Cases, where possible, will help with interoperability. Execution in rule engines compliant to RuleML, e.g. in OO jDREW and Prova, will permit benchmarking. Results of these validations, partial alignments, and test executions shall be documented (including with a few screenshots).

The Test Case Suite will be developed and made available in Github on the Web, open source, so it can be pointed to from the RuleML site.

 

RuleML 1.0 Overview:

http://www.cs.unb.ca/~boley/talks/RuleML-Overarching-Talk.pdf

 

RuleML Systematics:

http://wiki.ruleml.org/index.php/RuleML_Systematics

 

RuleML 1.0 Examples (grouped according to sublanguages):

http://ruleml.org/1.0/exa

W3C RIF  Test Cases:
http://www.w3.org/2005/rules/wiki/Category:Test_Case

The Wine Ontology (for benchmarking RuleML and POSL tools):
http://ruleml.org/usecases/wineonto

 

Earlier benchmarks (showing OO jDREW speedup):

http://wiki.ruleml.org/index.php/OO_jDREW:Benchmarks

 

Prova:

http://www.prova.ws

 

Github (Tutorial): http://learn.github.com/p/intro.html
Github (RuleML): https://github.com/RuleML

 

Tara Athan,

Harold Boley

Team 4 Testing, Inverting, and Round-Tripping the RON Normalizer for RuleML 1.0 in XSLT 2.0

Simranjit Singh,

Bijiteshwar R. Aayush,

Pratik Shah


RuleML 1.0 rules and queries are marked up (serialized) in an ‘object-oriented’ flavor of XML, where XML trees alternate elements that act as Classes/Types (Nodes) or methods/roles (edges). There are various equivalent ways of such (Node-edge-… -Node-edge-Node-)‘striped’ XML serialization, even apart from logical equivalences. For example, the <Implies> node (the main element for rules) normally contains an <if> and a <then> edge (subelements for the rule premise and conclusion, respectively). But, when written in this natural ‘if-then’ sequence, the left-to-right order of XML subelements can be relied upon, and the stripe of <if> and <then> edges may be omitted. Normalizers for RuleML/XML were developed for transforming such ‘stripe-skipped’ serializations to the original ‘fully striped’ ones.

The current XSLT 2.0-based normalizer RON shall be: (a) tested for a suite of systematic sample transformations over facts, rules and queries, which may lead to suggestions for RON improvements; (b) ‘inverted’ for the XSLT 2.0 transformation of ‘fully striped’ (or ‘partially striped’) serializations back to (maximally compact) ‘stripe-skipped’ ones, and tested with the suite from (a); (c) composed with the ‘inverse’ from (b) in both possible ways for exploring round-tripping, which may lead to improvements of (a) or (b) or both.

The results of (a)-(c) will be made available on the Web, open source, so they can be pointed to from the RuleML (Implementations) site.

 

XSLT:
http://www.xfront.com/rescuing-xslt.html

http://www.cafeconleche.org/books/bible3/chapters/ch15.html

http://www.w3.org/2005/08/online_xslt

 

RuleML 1.0 Normalization

http://ruleml.org/1.0/#Normalizer

 

RON (documentation and initial implementation):

http://v37s3b4h7dn47s37hg1br4h7rs7n3du7s8nu.unbf.ca/~lbidlak1/

RON (newest implementation):
http://ruleml.org/1.0/xslt/normalizer/

 

Tara Athan,

Harold Boley

Team 5 Implementing SWRL Built-Ins and Typed Tokenizing for OO jDREW in Java

Nicolas Neu,

Olav Hermansen,

Ikhtear Md. Sharif Bhuyan

 

The Object Oriented Java Deductive Reasoning Engine for the Web (OO jDREW) has a Top Down mode that executes queries over facts and rules for a Naf Hornlog subset of RuleML 1.0 in Java. The corresponding OO jDREW Bottom Up mode shares with OO jDREW Top Down the implementation of types, built-ins, etc. Github is hosting the entire OO jDREW rule engine development.

The current implementation of OO jDREW built-ins has two issues, which shall be resolved in this project and exemplified with test cases: (1) The implementation is based on the SWRL built-ins, which have meanwhile been updated as part of the Protégé SWRLTab. Moreover, it is partial, e.g., neither date and time types nor built-ins are implemented. This can be fixed incrementally using the OO jDREW Built-Ins document as a guide, also updating the OO jDREW versions of any updated SWRL built-ins. The documentation should prepare complementing SWRL built-ins by other proposed Web built-ins such as by W3C RIF (2) Arguments to built-ins require the use of typed constants such as 18:Integer (with the POSL 1.0 update: 18^^Integer or RIF-style "18"^^Integer), which looks often quite redundant/repetitive, especially since ‘system types’ such as Integer need not be written when constants are used as arguments to other, non-built-in predicates or functions. A simple kind of ‘type inference’ -- as in many tokenizers -- should be employed to recognize that 18 is to be read as 18:Integer etc.

The issue resolutions will be developed and added to the open source Github repository for OO jDREW on the Web, so they can be pointed to from the OO jDREW and RuleML sites.

 

OO jDREW as a reference implementation of RuleML:
www.jdrew.org/oojdrew/OOjDREW-RefImp-talk.ppt

http://nparc.cisti-icist.nrc-cnrc.gc.ca/npsi/ctrl?action=shwart&index=an&req=8914311&lang=en

 

jDREW introduction:
http://www.cs.unb.ca/~boley/cs6795swt/cs6795swt-jDREW.pdf

http://clip.dia.fi.upm.es/Conferences/Colognet/ITCLS-2002/PAPERS/BruceSpencer.pdf

 

OO jDREW homepage:

http://www.jdrew.org/oojdrew

 

OO jDREW wiki:

http://wiki.ruleml.org/index.php/Main_Page#OO_jDREW

 

OO jDREW Built-Ins (Examples): http://www.jdrew.org/oojdrew/docs/builtins.html

OO jDREW Built-Ins (Built-Ins): http://www.jdrew.org/oojdrew/builtins.html

OO jDREW Built-Ins (Creation): http://www.jdrew.org/oojdrew/docs/builtinsguide.pdf

 

Github (Tutorial): http://learn.github.com/p/intro.html
Github (OO jDREW): https://github.com/OOjDREW

 

Tara Athan,

Harold Boley

Team 6 Generating a Library of RuleML 1.0 Schemas

Jeevan Reddy Kodur,

Hawra Bader Alseef

 

The RuleML 1.0 schemas in Relax NG consist of a ‘backbone’ of named schemas enriched by a large number of parameter-defined schemas customizable via a schema generator, MYNG. This tool, written by Tara Athan in PHP, presents itself as a dashboard-like GUI, where users enter parameters of ten categories/facets describing what their RuleML 1.0 sublanguage ought to express. It then generates the desired schema in the Relax NG Compact (RNC) schema syntax, uniquely identified by a (query-parameterized) URL. For example, while there is an XSD-specified RuleML 1.0 sublanguage of Datalog with all relations restricted to being binary (bindatalog), the tool-supported schema parameterization permits the RNC-specified RuleML 1.0 to customize all sublanguages (not only Datalog) with such a binary restriction. The tool shall be used to systematically generate relevant RuleML 1.0 sublanguages in RNC, which shall then be used to validate sample instances. Based on this, a RuleML 1.0 Schema Library of interesting RNC specifications shall be built, tested, and illustrated with examples from any knowledge domain.

The Schema Library will be made available on the Web, open source, so it can be pointed to from the RuleML and MYNG sites.

 

RuleML schema modularization (including bindatalog):

http://ruleml.org/modularization

 

Paper on Customization of RuleML in Relax NG:
www.cs.unb.ca/~boley/papers/RuleMLinRelaxNG.pdf

 

Relax NG and PHP-implemented schema-parameterization tool:

http://wiki.ruleml.org/index.php/MYNG

http://wiki.ruleml.org/index.php/MYNG#PHP_Parameterized_Schema
http://ruleml.org/1.0/myng

 

Tara Athan,

Harold Boley

Team 7 Specifying Units of Measure in POSL and RuleML 1.0: Targeting OO jDREW Execution

Chandan Bagai,

Sunil Kumar Ravikumar,

Udit Trivedi

 

Converting between measurement systems can be seen as the ‘drosophila’ of knowledge interoperation. The specification of Units of Measure has been a popular use case for ontologies and rules since Tom Gruber's pioneering work in Ontolingua.

Based on the seeds given below, the project will explore the literature in this area. It will also build a library specifying Units of Measure in POSL and RuleML. The majority of the specification should be executable in OO jDREW’s Naf Hornlog, possibly after pre-processing. A hierarchy of expressivity should be defined for Units of Measure specifications that require Datalog, Hornlog, Naf Hornlog, FOL, and beyond. The combination of these rule-formalizing logics up to Naf Hornlog with ontology-formalizing logics should be considered, from RDFS-style subClassOf hierarchies (which can be used as type/sort lattices for restricting rule variables in OO jDREW) to ALC-derived Description Logics (which are usually combined with Datalog only, the prime example being SWRL, combining OWL-DL’s Description Logic SHOIN(D) with RuleML’s Unary/Binary Datalog). Another research question should be the invertibility of transformations between units (such as for symmetrically converting temperatures between Fahrenheit and Celsius), which may call for multiple mode declarations or constraint propagation techniques.

The results will be made available on the Web, open source, so they can be pointed to from the RuleML and OO jDREW sites.

 

Frank Olken: An Ontology of Measurement Units and Dimensions:
http://ontolog.cim3.net/file/work/OntologySummit2009/OntologySummit2009_Symposium_20090406-07/units-ontology-talk-v01--FrankOlken_20090406.pdf

 

Harold Abelson and Gerald Jay Sussman: Structure and Interpretation

of Computer Programs. Chapter: Propagation of Constraints:

http://mitpress.mit.edu/sicp/full-text/sicp/book/node65.html

 

OASIS Quantities and Units of Measure Ontology Standard (QUOMOS) TC: https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=quomos

NIST UnitsML:

http://unitsml.nist.gov/Presentations/UnitsML-SCC20.ppt

 

Ontolingua Quantities and Units:

http://www-ksl.stanford.edu/htw/dme/thermal-kb-tour/physical-quantities.html

http://www-ksl.stanford.edu/htw/dme/thermal-kb-tour/standard-units.html

Harold Boley

Team 8 Visualizing SWRL’s Unary/Binary Datalog RuleML in Grailog

Bo Yan,

Junyan Zhang,

Ismail Akbari

 

The Semantic Web Rule Language (SWRL) has been one of the most popular Web rule languages, possibly because of its use as SWRLTab in the very wide-spread Protégé ontology editor and knowledge-base framework. SWRL employs Unary/Binary Datalog formulas, which can also be seen as slotted formulas in F-logic, W3C RIF-BLD, or PSOA RuleML terms. This allows two alternate Grailog visualization methods.

Both shall be explored and compared in the project. Further comparisons are to be made with the Axiomé visualizer for SWRL rules. One of the two Grailog visualization methods will be chosen. The implementation approach for it can be chosen amongs the open-source Axiomé, further Protégé visualizers (e.g., Jambalaya/OntoGraf or OWLViz for OWL ontologies), or other approaches. The Grailog visualization will be exemplified with a SWRL rule set from the Protégé site.

The results will be made available on the Web, open source, so they can be pointed to from the RuleML and Grailog sites.

 

Grailog Slides (e.g. slide 111): http://www.cs.unb.ca/~boley/talks/RuleMLGrailog.pdf

 

SWRLTab: http://protege.cim3.net/cgi-bin/wiki.pl?SWRLTab

 

Saeed Hassanpour: Axiomé: http://protegewiki.stanford.edu/wiki/Axiomé

Harold Boley

Team 9 Schema.org Combined with Rules for the Semantic Annotation of HTML5 Pages

Swapnil Sule,

Manisha Gupta,

Sharath Chandra Maddur

 

The Semantic Web is getting mainstream with HTML5 Microdata and Schema.org, which permit the universal semantic annotation of Web pages. Schema.org’s Type Hierarchy is a candidate ‘upper-level’ multi-hierarchical world-wide taxonomy, already used by extant search engines including Google, Yahoo!, Microsoft's Bing, and Yandex. Schema.RDFS.org provides the Schema.org Type Hierarchy in various formats including RDFS and JSON.

The project will employ the subClassOf definitions of the RDFS-formatted Type Hierarchy in OO jDREW, analyze them using OO jDREW’s Taxonomy Querying, and define RuleML 1.0 facts and rules some of whose variables are restricted by Schema.org classes. These definitions should refer to a coherent selection of Web pages containing HTML5 Microdata, associating them ‘horizontally’ to complement their ‘vertical’ association through the Type Hierarchy. The expressivity of the rules chosen (Datalog, Hornlog, or Naf Hornlog) should be explained and illustrated with examples. The interaction between ‘vertical’ and ‘horizontal’ parts of the formalized knowledge should be described.

The results will be made available on the Web, open source, so they can be pointed to from the RuleML site.

 

HTML Microdata: http://dev.w3.org/html5/md/

 

Schema.org (Description): http://schema.org/

Schema.org (Type Hierarchy): http://schema.org/docs/full.html

Schema.RDFS.org: http://schema.rdfs.org/

 

OO jDREW (Taxonomy Querying System):

http://www.jdrew.org/oojdrew/docs/TaxonomyQuerying.html

OO jDREW (Taxonomy Querying API):

http://www.jdrew.org/oojdrew/docs/TaxonomyQueryingAPI.html

 

Harold Boley

Team 10 Building an Ontology of Semantic Web Techniques Utilizing RDF Schema and OWL 2.0 in Protégé 4.0

Nimat Onize Umar,

Syed Muhammad Hasan,

Naveed Javed

 

Light-weight ontologies (in particular, the often used subClassOf taxonomies and the occasionally used subPropertyOf taxonomies) can be encoded with RDF Schema (RDFS). Increasingly heavy-weight ontologies can be encoded by adding property-defined classes with increasingly expressive fragments of OWL 2.0. All of these encodings can be generated by Protégé 4.0 from visual user input. Protégé 4.0 also permits inferencing with these ontologies employing plugged-in reasoners such as  Pellet 1.5.

In this project, Semantic Web Techniques as covered in the course CS 6795 shall be ontologically described on a high level, which can serve for inferential querying and as metadata for finding specific course material.  The Semantic Web Techniques ontology will be rooted in the class SemWebTech (level 0) and branch into subclasses FormalKnowledge (refined in “Distributed Semantic Web Knowledge Representation and Inferencing”), InferenceEngine, etc. (level 1). Similar subClassOf branching will continue across several further levels, constituting an RDFS backbone taxonomy in the form of a Directed Acyclic Graph (DAG). Using the course CS 6795 Mindmap” slide and “Notes and Lecture Schedule 2012” page (plus some of the linked course material) as semi-formal inputs, property-defined classes will be added to build a more heavy-weight OWL 2.0 SemWebTech ontology. This ontology will be populated by sample instances in the form of URLs of actual course material.

The populated ontology will be made available on the Web, open source, as a potential support for the SemWebTech course.

 

Mindmap Slide: http://www.cs.unb.ca/~boley/cs6795swt/cs6795swt-Mindmap.pdf

Distributed SemWeb KR & Inferencing Slideshttp://www.cs.unb.ca/~boley/talks/DistriSemWeb.pdf

Protégé OWL Tutorial: http://owl.cs.manchester.ac.uk/tutorials/protegeowltutorial/

 

Protégé Editor: http://protege.stanford.edu/

Pellet Reasoner: http://clarkparsia.com/pellet/

 

 

 

 


Maintained by Harold Boley