Checks whether constant is the String representation of a value in the
data range, where the string has to be interpreted according to the
datatype URI.
Given a map from nodes to a set of data ranges, construct a map from
nodes to data ranges such that each constructed data range captures all
restrictions of the data ranges in the set for the node in the given map.
Partition the set of nodes and their canonical data ranges together with
their inequalities into mutally disjoint non-empty subsets P1, ..., Pn
such that no Pi and Pj with i neq j have variables in common.
Can be used to check whether the implementation supports the given set of
datatypes, e.g., the implementation for integers supports long,
unsignedByte, etc.
Given a map with nodes and data range assertions for the nodes, check
whether there is an assignment for all the data ranges that is consistent
with the restrictions on the data ranges and the inequalities
Checks if in the last iteration a new data range assertion has been added
and if so, whether the restrictions on this newly added node and its data
range siblings are satisfiable given the asserted inequalities.
Conjoins the facet restrictions from the given data range, provided it is
of the same concrete implementation, i.e., we can conjoins the facets of
an instance of DatatypeRestrictionString to another instance of
DatatypeRestrictionString.
If exactly one of the classes in descriptions is an intersection, new
inclusions are added that each contain one intersection operand and all
the other descriptions.
Tries to fetch an integer that represents the time to the next breakpoint
in seconds from the arguments given to the constructor and
prints a list of nodes and their blocking status for nodes with a label
equal to the label of the node with the given ID
Tries to extract \"clash\" or \"unaryPredicateURI\" and \"nodeID\" or
\"binaryPredicateURI\" and \"nodeID\" and \"nodeID\" from the arguments
given to the constructor and transforms the predicateURI into an
DLPredicate and shows the derivation tree for the given predicate and
nodes or the clash
Finds the nodes with the given IDs, then prints for both nodes the
(positive) concepts that are in the label of one, but not in the label of
the other node.
Tries to fetch a concept name \"C\" from the arguments given to the
constructor and prints a list of nodes and their blocking status for
nodes that have been created by a concept of the form (atleast n r.C)
Tries to fetch a node ID from the arguments given to the constructor and
prints nodes and their blocking status that have the same pair-wise
blocking signature of the node for the given node ID.
Expands an at least concept by first trying a functional expansion (if the cardinality is 1 or the role is functional) and a normal expansion otherwise.
Extend the tableau (semantically the ontology associated with the tableau) with
the given clauses and facts which provide *only* definitions for some new
atomic concept names.
This extension table is for use with Description Graphs and it supports tuple
tables with arity greater than three, but are, as a result, less efficient.
Given a node that has a data range assertion in the extension table,
look up its predecessor node in the tableau (unique for data range nodes)
and collect all successors of the fond predecessor that have data range
assertions.
Takes the set of roles that are for use in Description Graphs and detects
whether clause contains no roles, only roles from the given set, only
roles not from the given set or both types of roles.
Given a map from data ranges to nodes and inequalities between the nodes,
check whether there is a suitable assignment of values for the nodes that
complies with the given datatype restrictions and inequalities.
Tests whether the clause conforms to the properties of HT clauses, i.e.,
the variables can be split into a centre variable x, a set of branch
variables y_i, and a set of nominal variables z_j such that certain
conditions hold.
Implements the merge rule and is used whenever the merge rule needs to be
applied during the expansion of the tableau object used in the constructor
of the class.
This class is responsible for mapping between URIs and "identifiers", which
can be given in any of three different formats:
1) <uri>
2) prefix:localpart
3) localpart
Forms 2 and 3 are dependent upon a set of namespace declarations which
associates namespaces with prefices.
Create a new Namespaces object with declarations copied from
`sources` (given in order of precedence) and using `defaultNamespace`
as (surprisingly enough) a default namespace.
This class constructs the subsumption hierarchy by taking the graph of all superclass relationships and then
identifying the strongly connected components using Tarjan's algorithm.
Performs a few tests depending on the type of the added tuple (concept,
role, inequality, description graph) to see whether adding the tuple
caused a clash.
Expand a full URI from `id`, which is of one of the following forms:
`name`, where `name` is an identifier containing no colon characters,
`prefix:name`, where `prefix` is a registered namespace prefix, or
`<uri>`, where `uri` is a URI.
Return a set of namespaces with both the contents of `n` and
prefices for all internal concepts, including shorthands for
internal nominal concepts based on the declarations from 'n'.