Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.mindswap.pellet
Class PelletOptions

    java.lang.Object
      org.mindswap.pellet.PelletOptions

    public class PelletOptions

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

Nested Class Summary
`static class` | `PelletOptions.MonitorType`

Field Summary
`static java.lang.String` | `ANON` Prefix to be added to anonymous individuals tableaux algorithm creates
`static boolean` | `AUTO_XML_SCHEMA_LOADING` Whenever an rdfs:Datatype is seen, Pellet can try to retrieve and parse the XML Schema document automatically.
`static java.lang.String` | `BNODE` Prefix to be added to bnode identifiers
`static boolean` | `BREADTH_FIRST`
`static boolean` | `CACHE_RETRIEVAL`
`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`.
`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.
`static java.lang.Class<? extends CompletionStrategy>` | `DEFAULT_COMPLETION_STRATEGY` The default strategy used for ABox completion.
`static java.lang.String` | `DEFAULT_CONFIGURATION_FILE`
`static boolean` | `DEPTH_FIRST`
`static boolean` | `DL_SAFE_RULES` This option tells the reasoner to enable support for DL-safe rules (encoded in SWRL).
`static boolean` | `DOUBLE_CHECK_ENTAILMENTS`
`static boolean` | `FREEZE_BUILTIN_NAMESPACES` With this option all triples that contains an unrecognized term from RDF, RDF-S, OWL, OWL 1.1, or XSD namespaces will be ignored.
`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.
`static boolean` | `IGNORE_DEPRECATED_TERMS` This option causes all classes and properties defined as deprecated (using `owl:DeprecetedClass` or `owl:DeprecetedProperty`) to be ignored.
`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.
`static boolean` | `IGNORE_UNSUPPORTED_AXIOMS` This option controls the behavior of Pellet while an ontology is being loaded.
`static boolean` | `KEEP_ABOX_ASSERTIONS` Keep ABox assertions in the KB so they can be accessed later.
`static org.apache.commons.logging.Log` | `log`
`static boolean` | `MAINTAIN_COMPLETION_QUEUE` Flag if the completion queue should be maintained through incremental deletions.
`static java.lang.String` | `NO_SORTING`
`static java.lang.String` | `OLDEST_FIRST`
`static boolean` | `PRINT_ABOX` Print completion graph after each iteration (Should be used only for debugging purposes).
`static boolean` | `PRINT_SIZE` Deprecated. Set KnowledgeBase debug level to info
`static boolean` | `REALIZE_INDIVIDUAL_AT_A_TIME` Control the realization strategy where we loop over individuals or concepts.
`static boolean` | `REORDER_QUERY` Deprecated. Set SAMPLING_RATIO to 0 to disable query reordering
`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.
`static double` | `SAMPLING_RATIO` The ratio of individuals that will be inspected while generating the size estimate.
`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.
`static boolean` | `SEARCH_TYPE`
`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.
`static boolean` | `SIMPLIFY_QUERY` Remove query atoms that are trivially entailed by other atoms.
`static boolean` | `SPLIT_QUERY` Deprecated. Query is always split to ensure correctness
`static boolean` | `TREAT_ALL_VARS_DISTINGUISHED` Deprecated. According to SPARQL semantics all variables are distinguished by definition and bnodes in the query are non-distinguished variables so this option is not used anymore
`static boolean` | `USE_ABSORPTION` TBox absorption will be used to move some of the General Inclusion Axioms (GCI) from Tg to Tu.
`static boolean` | `USE_ADVANCED_CACHING` Cache the pseudo models for anonymous classes.
`static boolean` | `USE_BACKJUMPING` Use dependency directed backjumping
`static boolean` | `USE_BINARY_INSTANCE_RETRIEVAL`
`static boolean` | `USE_CACHING` Cache the pseudo models for named classes and individuals.
`static boolean` | `USE_CD_CLASSIFICATION` Use (if applicable) special optimization for completely defined (CD) concepts during classification.
`static PelletOptions.MonitorType` | `USE_CLASSIFICATION_MONITOR`
`static boolean` | `USE_COMPLETION_QUEUE` Flag set if the completion queue should be utilized.
`static boolean` | `USE_COMPLETION_STRATEGY` Dynamically find the best completion strategy for the KB.
`static boolean` | `USE_CONTINUOUS_RULES` Use continuous rete execution for applying rules.
`static boolean` | `USE_DISJUNCT_SORTING` Sort the disjuncts based on the statistics
`static java.lang.String` | `USE_DISJUNCTION_SORTING`
`static boolean` | `USE_FULL_DATATYPE_REASONING` Check the cardinality restrictions on datatype properties and handle inverse functional datatype properties
`static boolean` | `USE_HASVALUE_ABSORPTION`
`static boolean` | `USE_INCREMENTAL_CONSISTENCY` Flag set if incremental consistency checking should be used.
`static boolean` | `USE_INCREMENTAL_DELETION` Flag set if incremental support for deletions should be used.
`static boolean` | `USE_LOCAL_NAME` When this option is enabled all entities (classes, properties, individuals) are identified using local names rather than full URI's.
`static boolean` | `USE_NOMINAL_ABSORPTION` Absorb TBox axioms about nominals into ABox assertions
`static boolean` | `USE_OPTIMIZEDINDIVIDUALS` Optimization specific to Econnections
`static boolean` | `USE_PSEUDO_MODEL` When a consistency check starts in ABox use the cached pseudo model as the starting point rather than the original ABox.
`static boolean` | `USE_PSEUDO_NOMINALS` Treat nominals (classes defined by enumeration) as named atomic concepts rather than individual names.
`static boolean` | `USE_QNAME`
`static boolean` | `USE_ROLE_ABSORPTION` Absorb TBox axioms into domain/range restrictions in RBox
`static boolean` | `USE_SEMANTIC_BRANCHING` Use semantic branching, i.e.
`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.
`static boolean` | `USE_TRACING`
`static boolean` | `USE_UNIQUE_NAME_ASSUMPTION` This option tells Pellet to treat every individual with a distinct URI to be different from each other.
`static boolean` | `VALIDATE_ABOX` Validate ABox structure during completion (Should be used only for debugging purposes).

Constructor Summary
`PelletOptions()`

Method Summary

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### log

    public static final org.apache.commons.logging.Log log

### 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.

### TREAT_ALL_VARS_DISTINGUISHED

    public static boolean TREAT_ALL_VARS_DISTINGUISHED

  Deprecated. According to SPARQL semantics all variables are distinguished by definition and bnodes in the query are non-distinguished variables so this option is not used anymore

### USE_DISJUNCT_SORTING

    public static boolean USE_DISJUNCT_SORTING

  Sort the disjuncts based on the statistics

### USE_CLASSIFICATION_MONITOR

    public static PelletOptions.MonitorType USE_CLASSIFICATION_MONITOR

### NO_SORTING

    public static final java.lang.String NO_SORTING

See Also:
  Constant Field Values

### OLDEST_FIRST

    public static final java.lang.String OLDEST_FIRST

See Also:
  Constant Field Values

### USE_DISJUNCTION_SORTING

    public static java.lang.String USE_DISJUNCTION_SORTING

### USE_LOCAL_NAME

    public static boolean USE_LOCAL_NAME

  When this option is enabled all entities (classes, properties, individuals) are identified using local names rather than full URI's. This makes the debugging messages shorter and easier to inspect by eye. This options should be used with care because it is relatively easy to have local names with different namespaces clash.

  *** This option should only be used for debugging purposes. ***

### USE_QNAME

    public static boolean USE_QNAME

### 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.

### 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_OPTIMIZEDINDIVIDUALS

    public static boolean USE_OPTIMIZEDINDIVIDUALS

  Optimization specific to Econnections

### 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

### AUTO_XML_SCHEMA_LOADING

    public static boolean AUTO_XML_SCHEMA_LOADING

  Whenever an rdfs:Datatype is seen, Pellet can try to retrieve and parse the XML Schema document automatically. Otherwise, the datatype will be treated as an unknown datatype

### 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.

### 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_MODEL

    public static boolean USE_PSEUDO_MODEL

  When a consistency check starts in ABox use the cached pseudo model as the starting point rather than the original ABox. Since all the branching information is already stored in the pseudo model, this should be logically equivalent but much faster

### 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 SHION strategy will be used for all the ontologies.

### USE_CONTINUOUS_RULES

    public static boolean USE_CONTINUOUS_RULES

  Use continuous rete execution for applying rules.

### 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

### DEFAULT_COMPLETION_STRATEGY

    public static java.lang.Class<? extends CompletionStrategy> DEFAULT_COMPLETION_STRATEGY

  The default strategy used for ABox completion. If this values is set, this strategy will be used for all the KB's regardless of the expressivity.

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

### PRINT_SIZE

    public static boolean PRINT_SIZE

  Deprecated. Set KnowledgeBase debug level to info
  Print the size of the TBox and ABox after parsing.

### BNODE

    public static final java.lang.String BNODE

  Prefix to be added to bnode identifiers

  See Also:
    Constant Field Values

### ANON

    public static final java.lang.String ANON

  Prefix to be added to anonymous individuals tableaux algorithm creates

  See Also:
    Constant Field Values

### 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.

### 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).

### DEPTH_FIRST

    public static final boolean DEPTH_FIRST

See Also:
  Constant Field Values

### BREADTH_FIRST

    public static final boolean BREADTH_FIRST

See Also:
  Constant Field Values

### 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

### USE_BINARY_INSTANCE_RETRIEVAL

    public static boolean USE_BINARY_INSTANCE_RETRIEVAL

### SPLIT_QUERY

    public static boolean SPLIT_QUERY

  Deprecated. Query is always split to ensure correctness

### 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`.

### REORDER_QUERY

    public static boolean REORDER_QUERY

  Deprecated. Set SAMPLING_RATIO to 0 to disable query reordering

### 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.

### 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

### DOUBLE_CHECK_ENTAILMENTS

    public static boolean DOUBLE_CHECK_ENTAILMENTS

### 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 1.1, 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

    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.

### 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_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.

Constructor Detail

### PelletOptions

    public PelletOptions()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2004 Evren Sirin. All Rights Reserved.