Package openllet.core

Class OpenlletOptions

  • public class OpenlletOptions
extends java.lang.Object
    This class contains options used throughout different modules of the reasoner. Setting one of the values should have effect in the behavior of the reasoner regardless of whether it is based on Jena or OWL-API (though some options are applicable only in one implementation). Some of these options are to control experimental extensions to the reasoner and may be removed in future releases as these features are completely tested and integrated.
    Author:
    Evren Sirin

    • Field Detail

      • _logger

        public static final java.util.logging.Logger _logger

      • SATURATE_TABLEAU

        public static boolean SATURATE_TABLEAU
        When this option is set completion will go on even if a clash is detected until the completion graph is saturated. Turning this option has very severe performance effect and right now is only used for experimental purposes to generate explanations.

        *********** DO NOT CHANGE THE VALUE OF THIS OPTION **************

      • USE_UNIQUE_NAME_ASSUMPTION

        public static boolean USE_UNIQUE_NAME_ASSUMPTION
        This option tells Pellet to treat every _individual with a distinct URI to be different from each other. This is against the semantics of OWL but is much more efficient than adding an definition with all the individuals. This option does not affect b-_nodes, they can still be inferred to be same.

      • TRACK_BRANCH_EFFECTS

        public static boolean TRACK_BRANCH_EFFECTS
        Track the association betweens _nodes changed and _branch. Reduces the work done during restoration (and during some incremental reasoning changes), at the cost of memory overhead necessary for tracking.

      • TREAT_ALL_VARS_DISTINGUISHED

        public static boolean TREAT_ALL_VARS_DISTINGUISHED
        According to SPARQL semantics all variables are distinguished by definition and bnodes in the query are non-distinguished variables. This option overrides the default behavior and treats bnodes as distinguished variables, too. This means bnodes in the SPARQL query will only be matched to named individuals or existing bnodes in the dataset but not to inferred individuals (e.g. an _individual whose existence is inferred due to an owl:someValuesFrom restriction)

      • USE_DISJUNCT_SORTING

        public static boolean USE_DISJUNCT_SORTING
        Sort the disjuncts based on the statistics

      • USE_DISJUNCTION_SORTING

        public static java.lang.String USE_DISJUNCTION_SORTING

      • USE_ABSORPTION

        public static boolean USE_ABSORPTION
        TBox absorption will be used to move some of the General Inclusion Axioms (GCI) from Tg to Tu.

      • UNDEFINED_DATATYPE_HANDLING

        public static OpenlletOptions.UndefinedDatatypeHandling UNDEFINED_DATATYPE_HANDLING
        If EXCEPTION an exception is thrown when the reasoner encounters an undefined (and unsupported) datatype. If EMPTY it is treated as an empty datatype and has no valid lexical forms. If INFINITE it is treated as an infinite datatype and all lexical forms are valid and in which equality and identity is based on lexical form.

      • USE_ROLE_ABSORPTION

        public static boolean USE_ROLE_ABSORPTION
        Absorb TBox axioms into domain/range restrictions in RBox

      • USE_NOMINAL_ABSORPTION

        public static boolean USE_NOMINAL_ABSORPTION
        Absorb TBox axioms about nominals into ABox assertions

      • USE_HASVALUE_ABSORPTION

        public static boolean USE_HASVALUE_ABSORPTION

      • USE_RULE_ABSORPTION

        public static boolean USE_RULE_ABSORPTION

      • USE_BINARY_ABSORPTION

        public static boolean USE_BINARY_ABSORPTION

      • USE_BACKJUMPING

        public static boolean USE_BACKJUMPING
        Use dependency directed backjumping

      • USE_FULL_DATATYPE_REASONING

        public static boolean USE_FULL_DATATYPE_REASONING
        Check the cardinality restrictions on datatype properties and handle inverse functional datatype properties

      • USE_CACHING

        public static boolean USE_CACHING
        Cache the pseudo models for named classes and individuals.

      • USE_ADVANCED_CACHING

        public static boolean USE_ADVANCED_CACHING
        Cache the pseudo models for anonymous classes. Used inside EmptySHNStrategy to prevent the expansion of completion graph _nodes whose satisfiability status is already cached.

      • USE_INVERSE_CACHING

        public static boolean USE_INVERSE_CACHING
        Cache the pseudo models for anonymous classes when inverses are present. This can improve reasoning performance but will introduce memory overhead.

      • USE_ANYWHERE_BLOCKING

        public static boolean USE_ANYWHERE_BLOCKING

      • MAX_ANONYMOUS_CACHE

        public static int MAX_ANONYMOUS_CACHE
        The maximum number of cached pseudo models for anonymous classes. The named concepts (and their negations) are always cached regardless of this limit. This setting is mostly relevant for SHN ontologies as USE_ADVANCED_CACHING option. If the _cache reaches the maximum number of entries for anonymous classes the subsequent additions will be handled specially (default behavior is to remove the Least Recently Used (LRU) element from _cache). Setting this value too high will increase the memory requirements and setting it too low will slow down the reasoning process.

      • CHECK_NOMINAL_EDGES

        public static boolean CHECK_NOMINAL_EDGES
        To decide if _individual i has type class _c check if the edges from cached model of _c to nominal _nodes also exists for the cached model of i.

      • USE_PSEUDO_NOMINALS

        public static boolean USE_PSEUDO_NOMINALS
        Treat nominals (classes defined by enumeration) as named atomic concepts rather than _individual names. Turning this option improves the performance but soundness and completeness cannot be established.

      • IGNORE_INVERSES

        public static boolean IGNORE_INVERSES
        This option is mainly used for debugging and causes the reasoner to ignore all inverse properties including inverseOf, InverseFunctionalProperty and SymmetricProperty definitions.

      • USE_COMPLETION_STRATEGY

        public static boolean USE_COMPLETION_STRATEGY
        Dynamically find the best completion _strategy for the KB. If disabled SROIQ _strategy will be used for all the ontologies.

      • USE_CONTINUOUS_RULES

        public static boolean USE_CONTINUOUS_RULES
        Use continuous rete execution for applying rules.

      • ALWAYS_REBUILD_RETE

        public static boolean ALWAYS_REBUILD_RETE
        Always rebuild rete (no incremental update)

      • USE_SEMANTIC_BRANCHING

        public static boolean USE_SEMANTIC_BRANCHING
        Use semantic branching, i.e. add the negation of a disjunct when the next _branch is being tried

      • COPY_ON_WRITE

        public static boolean COPY_ON_WRITE
        When doing a satisfiability check for a concept, do not copy the individuals even if there are nominals in the KB until you hit a nominal rule application.

      • SILENT_UNDEFINED_ENTITY_HANDLING

        public static boolean SILENT_UNDEFINED_ENTITY_HANDLING
        Control the behavior if a function such as kb.getInstances(), kb.getTypes(), kb.getPropertyValues() is called with a parameter that is an undefined class, property or _individual. If this option is set to false then an exception is thrown each time this occurs, if true set the corresponding function returns a false value (or an empty set where appropriate).

      • REALIZE_INDIVIDUAL_AT_A_TIME

        public static boolean REALIZE_INDIVIDUAL_AT_A_TIME
        Control the realization _strategy where we loop over individuals or concepts. When this flag is set we loop over each _individual and find the most specific type for that _individual by traversing the class hierarchy. If this flag is not set we traverse the class hierarchy and for each concept find the instances. Then any _individual that is also an instance of a subclass is removed. Both techniques have advantages and disadvantages. Best performance depends on the ontology characteristics.

      • AUTO_REALIZE

        public static boolean AUTO_REALIZE
        When this options is set, all the individuals in the KB are realized automatically when the types for one _individual is retrieved. This might be quite costly when there are a large number of individuals and might be wasted computation if the KB is changed frequently.

      • VALIDATE_ABOX

        public static boolean VALIDATE_ABOX
        Validate ABox structure during completion (Should be used only for debugging purposes).

      • PRINT_ABOX

        public static boolean PRINT_ABOX
        Print completion graph after each iteration (Should be used only for debugging purposes).

      • KEEP_ABOX_ASSERTIONS

        public static boolean KEEP_ABOX_ASSERTIONS
        Keep ABox assertions in the KB so they can be accessed later. Currently not used by the reasoner but could be useful for outside applications.

      • SEARCH_TYPE

        public static boolean SEARCH_TYPE

      • INVALID_LITERAL_AS_INCONSISTENCY

        public static boolean INVALID_LITERAL_AS_INCONSISTENCY
        If true invalid literals cause inconsistencies. If false they cause exceptions to be generated.

      • OPTIMIZE_DOWN_MONOTONIC

        public static boolean OPTIMIZE_DOWN_MONOTONIC
        When this option is set the query engine for distinguished variables uses taxonomies to prune downmonotonic variables in subClassOf and subPropertyOf atoms.

      • SIMPLIFY_QUERY

        public static boolean SIMPLIFY_QUERY
        Remove query atoms that are trivially entailed by other atoms. For example, the query
        query(x, y) :- Person(x), worksAt(x, y), Organization(y)
        can be simplified to
        query(x, y) :- worksAt(x, y)
        if the domain of worksAt is Person and the range is Organization.

      • SAMPLING_RATIO

        public static double SAMPLING_RATIO
        The ratio of individuals that will be inspected while generating the size estimate. The query reordering optimization uses size estimates for classes and properties to estimate the cost of a certain query ordering. The size estimates are computed by random sampling. Increasing the sampling ratio yields more accurate results but is very costly for large ABoxes.

      • STATIC_REORDERING_LIMIT

        public static int STATIC_REORDERING_LIMIT
        The number of query atoms in a query that will trigger the switch from static query reordering to dynamic (incremental) query reordering.

      • FULL_SIZE_ESTIMATE

        public static boolean FULL_SIZE_ESTIMATE
        This option controls if the size estimates for all the classes and properties in a KB will be computed fully when the PelletQueryExecution object is created.

      • CACHE_RETRIEVAL

        public static boolean CACHE_RETRIEVAL

      • USE_TRACING

        public static boolean USE_TRACING

      • DEFAULT_CONFIGURATION_FILE

        public static java.lang.String DEFAULT_CONFIGURATION_FILE

      • FREEZE_BUILTIN_NAMESPACES

        public static boolean FREEZE_BUILTIN_NAMESPACES
        With this option all triples that contains an unrecognized term from RDF, RDF-S, OWL, OWL 2, or XSD namespaces will be ignored.

      • IGNORE_DEPRECATED_TERMS

        public static boolean IGNORE_DEPRECATED_TERMS
        This option causes all classes and properties defined as deprecated (using owl:DeprecetedClass or owl:DeprecetedProperty) to be ignored. If turned off, these will be treated as ordinary classes and properties. Note that, even if this option is turned on deprecated entities used in ordinary axioms will be added to the KB.

      • IGNORE_UNSUPPORTED_AXIOMS

        public static boolean IGNORE_UNSUPPORTED_AXIOMS
        This option controls the behavior of Pellet while an ontology is being loaded. Some axioms, e.g. cardinality restrictions on transitive properties, is not supported by Pellet. If an axiom is used in the input ontology Pellet can just ignore that axiom (and print a warning) or simply throw an exception at the time that axiom is added to the KB. Default behavior is to ignore unsupported axioms.

      • DL_SAFE_RULES

        public static boolean DL_SAFE_RULES
        This option tells the reasoner to enable support for DL-safe rules (encoded in SWRL). If the value is set to ture then the rules will be taken into account during reasoning. Otherwise, rules will simply be ignored by the reasoner. Note that, some SWRL features such as DatavaluedPropertyAtom and BuiltinAtom is not supported. The behavior for what happens when rules containing such atoms is controlled by the IGNORE_UNSUPPORTED_AXIOMS option, e.g. such rules can be ignored or reasoner can throw an exception.

      • RETURN_DEDUCTIONS_GRAPH

        @Deprecated
public static boolean RETURN_DEDUCTIONS_GRAPH
        Deprecated.
        This option is introduced as a temporary solution for backward compatibility and is scheduled to be removed in future releases. One should avoid using InfGraph.getDeductionsGraph() (similarly InfModel.getDeductionsModel()) with Pellet. Model.listStatements() can be used to retrieve all the asserted and inferred statements.
        This option controls the behavior of PelletInfGraph.getDeductionsGraph() function affecting in turn how InfModel.getDeductionsGraph() behave. Jena documentation describes this function to apply only to forward-chaining rule engines which does not include pellet. The behavior of this function in Pellet prior to 1.5.1 release was to return an incomplete subset of all the inferences that the reasoner can compute from the base model. This is obviously not correct and Pellet should simply return null for this function according to the Jena documentation. But considering that the incorrect behavior of this function might already be being used by the users, Pellet 1.5.1 introduces this option for backward compatibility and forces PelletInfGraph return to the previous incorrect behavior.

      • RETURN_NON_PRIMITIVE_EQUIVALENT_PROPERTIES

        public static boolean RETURN_NON_PRIMITIVE_EQUIVALENT_PROPERTIES
        If ask equivalence between property, Inverse(property) may be return.

      • USE_COMPLETION_QUEUE

        public static boolean USE_COMPLETION_QUEUE
        Flag set if the completion queue should be utilized. This optimization will introduce memory overhead but will (in some cases) dramatically reduce reasoning time. Rather than iterating over all individuals during the completion _strategy, only those which need to have the rules fired are selected for rule applications.

      • USE_OPTIMIZED_BASIC_COMPLETION_QUEUE

        public static boolean USE_OPTIMIZED_BASIC_COMPLETION_QUEUE
        Flag set if the optimized basic completion _queue should be used. The difference between the basic completion _queue is that it maintains queues of individuals for each rule type. In contrast the basic completion queue simply one list of individuals which all rules iterate over

      • USE_SMART_RESTORE

        public static boolean USE_SMART_RESTORE
        During backjumping use dependency set information to restore _node labels rather than restoring the label exactly to the previous state.

      • USE_INCREMENTAL_CONSISTENCY

        public static boolean USE_INCREMENTAL_CONSISTENCY
        Flag set if incremental consistency checking should be used. Currently it can only be used on KBs with SHIQ or SHOQ expressivity

      • USE_INCREMENTAL_DELETION

        public static boolean USE_INCREMENTAL_DELETION
        Flag set if incremental support for deletions should be used. Currently it can only be used on KBs with SHIQ or SHOQ expressivity. This flag is used as incremental deletions introduces memory overhead, which may not be suitable for some KBs

      • MAINTAIN_COMPLETION_QUEUE

        public static boolean MAINTAIN_COMPLETION_QUEUE
        Flag if the completion _queue should be maintained through incremental deletions. It can be the case that a removal of a syntactic assertion will require a queue element to be removed, as it is no longer applicable. If this is set to false then a simple check before each rule is fired will be performed - if the ds for the label is null, then the rule will not be fired. If this is set to true and tracing is on, then the _queue will be maintained through deletions. TODO: Note currently the queue maintenance is not implemented, so this should always be FALSE!

        *********** DO NOT CHANGE THE VALUE OF THIS OPTION **************

      • USE_CD_CLASSIFICATION

        public static boolean USE_CD_CLASSIFICATION
        Use (if applicable) special optimization for completely defined (CD) concepts during classification.

      • USE_NAIVE_QUERY_ENGINE

        @Deprecated
public static boolean USE_NAIVE_QUERY_ENGINE
        Deprecated.

      • USE_ANNOTATION_SUPPORT

        public static boolean USE_ANNOTATION_SUPPORT
        Activate annotation support in Pellet. If this variable is true, Ontology annotations are stored to the KB and they can be retrieved, either by querying the KB or using the query engines.

      • HIDE_TOP_PROPERTY_VALUES

        public static boolean HIDE_TOP_PROPERTY_VALUES
        Do not include owl:topObjectProperty and owl:topDataProperty values when retrieving the property values for an _individual. Even tough such values are trivially inferred according to OWL 2 semantics, including these values in results increase result size drastically. This option will not affect boolean queries (asking whether a towl:topObjectProperty b is entailed will still return true) or property queries (sub and super property queries will include top properties).

      • USE_LEGACY_TBOX

        public static boolean USE_LEGACY_TBOX

      • ORDERED_CLASSIFICATION

        public static OpenlletOptions.OrderedClassification ORDERED_CLASSIFICATION
        Classifier orders classes based on their usage to guarantee the correctness of the classification results. In certain cases, there might be no semantic reason to choose between two classes. In these cases, the reasoner can use a deterministic algorithm to choose which of the classes to process first. This option ensures that the reasoner will use same ordering at every run. Disabling this option means the classifier will break ties randomly which might result in different classification times.

      • DISABLE_EL_CLASSIFIER

        public static boolean DISABLE_EL_CLASSIFIER
        Do not use EL Classifier, even if the ontology is EL

      • PROCESS_JENA_UPDATES_INCREMENTALLY

        public static boolean PROCESS_JENA_UPDATES_INCREMENTALLY

      • IGNORE_ANNOTATION_CLASSES

        public static boolean IGNORE_ANNOTATION_CLASSES
        In some ontologies, such as the ones from OBO, annotations may be nested and contain type assertions on annotation values. Such type assertions will be treated as regular assertions and processed by the reasoner. This causes many superfluous logical axioms to be considered by the reasoner which might have significant impact on performance. This options tells Pellet to ignore such annotations. The set of URIs that will be treated as annotation classes are defined in AnnotationClasses and has to be programmatically modified. Annotation classes from OBO are included by default.

      • USE_THREADED_KERNEL

        public static boolean USE_THREADED_KERNEL

    • Constructor Detail

      • OpenlletOptions

        public OpenlletOptions()

    • Method Detail

      • setOptions

        public static java.util.Properties setOptions​(java.util.Properties newOptions)
        Sets the Pellet configuration options and returns the old values for the options.
        Parameters:
        newOptions - the new values for configuration options
        Returns:
        the old properties.

      • load

        public static void load​(java.net.URL configFile)
                 throws java.io.FileNotFoundException,
                        java.io.IOException
        Throws:
        java.io.FileNotFoundException
        java.io.IOException