 # rules

Visibility
1. Public
2. All

### Type Members

1. #### class HighLevelRuleDependencyGraph extends DefaultGraphImpl[Graph[Rule, LDiEdge], DiEdge]

Given a rule dependency graph (RDG), a high-level rule dependency graph (HLRDG) is a directed acyclic graph G = (V, E) such that

Given a rule dependency graph (RDG), a high-level rule dependency graph (HLRDG) is a directed acyclic graph G = (V, E) such that

• each vertex in V is a rule dependency graph which is strongly connected and
• each edge (v_i, v_j) in E denotes the dependency between them

The dependency between two rules r_i and r_j, denoted as r_i -> r_j resp. "r_i depends on r_j" indicates that the result r_j is used as input of r_i. In particular, that means we use the same direction in the graph although one would expect to have an edge from the rule r_j producing the data to the rule r_i consuming the data.

2. #### class RuleDependencyGraph extends DefaultGraphImpl[Rule, LDiEdge]

Given a set of rules R, a rule dependency graph (RDG) is a directed graph G = (V, E) such that

Given a set of rules R, a rule dependency graph (RDG) is a directed graph G = (V, E) such that

• each vertex in V represents a rule r_i from R and
• each edge (r_i, r_j) in E denotes the dependency between them

The dependency between two rules r_i and r_j, denoted as r_i -> r_j, resp. "r_i depends on r_j" indicates that the result of r_j is used as input of r_i. In particular, that means we use the same direction in the graph although one would expect to have an edge from the rule r_j producing the data to the rule r_i consuming the data.

Some notes about the types used: The Rule class stems from org.apache.jena.reasoner.rulesys and comprises a list of antecedents (body) and a list of consequents (head), i.e.

consequent [, consequent] <- antecedent [, antecedent]

where each consequent or antecedent can be a TriplePattern (i.e. a triple of Nodes, themselves being either variables, wildcards, embedded functors, uri or literal graph nodes), a Functor or a Rule.

The Graph and LDiEdge ('labeled directed edge') classes stem from scalax.collection which provides the main graph functionality. Considering a scalax.collection.Graph two kinds of Nodes are distinguished:

- Outer Nodes Outer nodes exist outside of the context of any particular graph and must be provided by the library user. When added to a graph, they will be transparently wrapped by a corresponding inner node. Outer nodes must satisfy the upper bound of the node type parameter of the graph - Inner Nodes Inner nodes are objects bound to a particular graph. They are transparently created on graph instantiation or on adding nodes to a graph. Inner nodes are instances of the inner class NodeT, hence the term, and are implementing the InnerNodeLike interface. An inner node acts as a container of the corresponding outer node also providing a wealth of graph functionality such as diSuccessors or pathTo. Inner nodes always equal to the contained, user-provided outer node thus facilitating interchangeability of inner and outer nodes in many situations. Note that NodeT is a path dependent type such as g.NodeT with g denoting a single graph instance.

(Descriptions taken from http://www.scala-graph.org/guides/core-inner-outer.html)

### Value Members

1. #### object HighLevelRuleDependencyGraphGenerator

A generator for a high-level rule dependency graph for a given rule dependency graph.

3. #### object RDFSLevel extends Enumeration

The ForwardRuleReasonerRDFS can be configured to work at three different compliance levels:

The ForwardRuleReasonerRDFS can be configured to work at three different compliance levels:

Full
This implements all of the RDFS axioms and closure rules with the exception of bNode entailments and datatypes (rdfD 1). See above for comments on these. This is an expensive mode because all statements in the data graph need to be checked for possible use of container membership properties. It also generates type assertions for all resources and properties mentioned in the data (rdf1, rdfs4a, rdfs4b).

Default
This omits the expensive checks for container membership properties and the "everything is a resource" and "everything used as a property is one" rules (rdf1, rdfs4a, rdfs4b). This mode does include all the axiomatic rules. Thus, for example, even materializing an "empty" RDF graph will return triples such as [rdf:type rdfs:range rdfs:Class].

Simple
This implements just the transitive closure of subPropertyOf and subClassOf relations, the domain and range entailments and the implications of subPropertyOf and subClassOf. It omits all of the axioms. This is probably the most useful mode but is not the default because it is a less complete implementation of the standard.

4. #### object ReasoningProfile extends Enumeration

An enumeration of reasoning profiles, which are usually different sets of rules with different complexity.

6. #### object RuleDependencyGraphGenerator extends Logging

A generator for a so-called dependency graph based on a given set of rules.

A generator for a so-called dependency graph based on a given set of rules. A dependency graph is a directed graph representing dependencies of several objects towards each other. It is possible to derive an evaluation order or the absence of an evaluation order that respects the given dependencies from the dependency graph.

7. #### object RuleEntailmentType extends Enumeration

The type of entailment of a rule, i.e.

The type of entailment of a rule, i.e. which kind of triples are involved in the entailment process.

8. #### object RuleSets

Predefined sets of rules.

9. #### package minimizer

A framework for applying batches of minimization rules to dependency graphs, possibly to fixed point.