org.semanticweb.HermiT.structural.OWLClausification Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.semanticweb.hermit Show documentation
Show all versions of org.semanticweb.hermit Show documentation
HermiT is reasoner for ontologies written using the Web
Ontology Language (OWL). Given an OWL file, HermiT can determine whether or
not the ontology is consistent, identify subsumption relationships between
classes, and much more.
This is the maven build of HermiT and is designed for people who wish to use
HermiT from within the OWL API. It is now versioned in the main HermiT
version repository, although not officially supported by the HermiT
developers.
The version number of this package is a composite of the HermiT version and
an value representing releases of this packaged version. So, 1.3.7.1 is the
first release of the mavenized version of HermiT based on the 1.3.7 release
of HermiT.
This package includes the Jautomata library
(http://jautomata.sourceforge.net/), and builds with it directly. This
library appears to be no longer under active development, and so a "fork"
seems appropriate. No development is intended or anticipated on this code
base.
/* Copyright 2008, 2009, 2010 by the Oxford University Computing Laboratory
This file is part of HermiT.
HermiT is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
HermiT is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with HermiT. If not, see descriptionGraphs) {
OWLDataFactory factory=rootOntology.getOWLOntologyManager().getOWLDataFactory();
String ontologyIRI=rootOntology.getOntologyID().getDefaultDocumentIRI()==null ? "urn:hermit:kb" : rootOntology.getOntologyID().getDefaultDocumentIRI().toString();
Collection importClosure=rootOntology.getImportsClosure();
OWLAxioms axioms=new OWLAxioms();
OWLNormalization normalization=new OWLNormalization(factory,axioms,0);
for (OWLOntology ontology : importClosure)
normalization.processOntology(ontology);
BuiltInPropertyManager builtInPropertyManager=new BuiltInPropertyManager(factory);
builtInPropertyManager.axiomatizeBuiltInPropertiesAsNeeded(axioms);
ObjectPropertyInclusionManager objectPropertyInclusionManager=new ObjectPropertyInclusionManager(axioms);
// now object property inclusion manager added all non-simple properties to axioms.m_complexObjectPropertyExpressions
// now that we know which roles are non-simple, we can decide which negative object property assertions have to be
// expressed as concept assertions so that transitivity rewriting applies properly.
objectPropertyInclusionManager.rewriteNegativeObjectPropertyAssertions(factory,axioms,normalization.m_definitions.size());
objectPropertyInclusionManager.rewriteAxioms(factory,axioms,0);
if (descriptionGraphs==null)
descriptionGraphs=Collections.emptySet();
OWLAxiomsExpressivity axiomsExpressivity=new OWLAxiomsExpressivity(axioms);
DLOntology dlOntology=clausify(factory,ontologyIRI,axioms,axiomsExpressivity,descriptionGraphs);
return new Object[] { objectPropertyInclusionManager,dlOntology };
}
public DLOntology clausify(OWLDataFactory factory,String ontologyIRI,OWLAxioms axioms,OWLAxiomsExpressivity axiomsExpressivity,Collection descriptionGraphs) {
Set dlClauses=new LinkedHashSet();
Set positiveFacts=new HashSet();
Set negativeFacts=new HashSet();
Set allUnknownDatatypeRestrictions=new HashSet();
for (OWLObjectPropertyExpression[] inclusion : axioms.m_simpleObjectPropertyInclusions) {
Atom subRoleAtom=getRoleAtom(inclusion[0],X,Y);
Atom superRoleAtom=getRoleAtom(inclusion[1],X,Y);
DLClause dlClause=DLClause.create(new Atom[] { superRoleAtom },new Atom[] { subRoleAtom });
dlClauses.add(dlClause);
}
for (OWLDataPropertyExpression[] inclusion : axioms.m_dataPropertyInclusions) {
Atom subProp=getRoleAtom(inclusion[0],X,Y);
Atom superProp=getRoleAtom(inclusion[1],X,Y);
DLClause dlClause=DLClause.create(new Atom[] { superProp },new Atom[] { subProp });
dlClauses.add(dlClause);
}
for (OWLObjectPropertyExpression objectPropertyExpression : axioms.m_asymmetricObjectProperties) {
Atom roleAtom=getRoleAtom(objectPropertyExpression,X,Y);
Atom inverseRoleAtom=getRoleAtom(objectPropertyExpression,Y,X);
DLClause dlClause=DLClause.create(new Atom[] {},new Atom[] { roleAtom,inverseRoleAtom });
dlClauses.add(dlClause);
}
for (OWLObjectPropertyExpression objectPropertyExpression : axioms.m_reflexiveObjectProperties) {
Atom roleAtom=getRoleAtom(objectPropertyExpression,X,X);
Atom bodyAtom=Atom.create(AtomicConcept.THING,X);
DLClause dlClause=DLClause.create(new Atom[] { roleAtom },new Atom[] { bodyAtom });
dlClauses.add(dlClause);
}
for (OWLObjectPropertyExpression objectPropertyExpression : axioms.m_irreflexiveObjectProperties) {
Atom roleAtom=getRoleAtom(objectPropertyExpression,X,X);
DLClause dlClause=DLClause.create(new Atom[] {},new Atom[] { roleAtom });
dlClauses.add(dlClause);
}
for (OWLObjectPropertyExpression[] properties : axioms.m_disjointObjectProperties)
for (int i=0;i atomicConcepts=new HashSet();
Set atomicObjectRoles=new HashSet();
Set complexObjectRoles=new HashSet();
Set atomicDataRoles=new HashSet();
for (OWLClass owlClass : axioms.m_classes)
atomicConcepts.add(AtomicConcept.create(owlClass.getIRI().toString()));
Set individuals=new HashSet();
for (OWLNamedIndividual owlIndividual : axioms.m_namedIndividuals) {
Individual individual=Individual.create(owlIndividual.getIRI().toString());
individuals.add(individual);
// all named individuals are tagged with a concept, so that keys/rules are
// only applied to them
if (!axioms.m_hasKeys.isEmpty() || !axioms.m_rules.isEmpty())
positiveFacts.add(Atom.create(AtomicConcept.INTERNAL_NAMED,individual));
}
for (OWLObjectProperty objectProperty : axioms.m_objectProperties)
atomicObjectRoles.add(AtomicRole.create(objectProperty.getIRI().toString()));
for (OWLObjectPropertyExpression objectPropertyExpression : axioms.m_complexObjectPropertyExpressions)
complexObjectRoles.add(getRole(objectPropertyExpression));
for (OWLDataProperty dataProperty : axioms.m_dataProperties)
atomicDataRoles.add(AtomicRole.create(dataProperty.getIRI().toString()));
// Clausify SWRL rules
if (!axioms.m_rules.isEmpty())
new NormalizedRuleClausifier(axioms.m_objectPropertiesOccurringInOWLAxioms,descriptionGraphs,dataRangeConverter,dlClauses).processRules(axioms.m_rules);
// Create the DL ontology
return new DLOntology(ontologyIRI,dlClauses,positiveFacts,negativeFacts,atomicConcepts,atomicObjectRoles,complexObjectRoles,atomicDataRoles,allUnknownDatatypeRestrictions,axioms.m_definedDatatypesIRIs,individuals,axiomsExpressivity.m_hasInverseRoles,axiomsExpressivity.m_hasAtMostRestrictions,axiomsExpressivity.m_hasNominals,axiomsExpressivity.m_hasDatatypes);
}
protected DLClause clausifyKey(OWLHasKeyAxiom object) {
List headAtoms=new ArrayList();
List bodyAtoms=new ArrayList();
// we have two named individuals (corresponding to X1 and X2) that
// might have to be equated
Variable X2=Variable.create("X2");
Variable X1=Variable.create("X1");
headAtoms.add(Atom.create(Equality.INSTANCE,X1,X2));
// keys only work on datatypes and named individuals
bodyAtoms.add(Atom.create(AtomicConcept.INTERNAL_NAMED,X1));
bodyAtoms.add(Atom.create(AtomicConcept.INTERNAL_NAMED,X2));
// the concept expression of a hasKey statement is either a concept
// name or a negated concept name after normalization
OWLClassExpression description=object.getClassExpression();
if (description instanceof OWLClass) {
OWLClass owlClass=(OWLClass)description;
if (!owlClass.isOWLThing()) {
bodyAtoms.add(Atom.create(AtomicConcept.create(owlClass.getIRI().toString()),X1));
bodyAtoms.add(Atom.create(AtomicConcept.create(owlClass.getIRI().toString()),X2));
}
}
else if (description instanceof OWLObjectComplementOf) {
OWLClassExpression internal=((OWLObjectComplementOf)description).getOperand();
if (internal instanceof OWLClass) {
OWLClass owlClass=(OWLClass)internal;
headAtoms.add(Atom.create(AtomicConcept.create(owlClass.getIRI().toString()),X1));
headAtoms.add(Atom.create(AtomicConcept.create(owlClass.getIRI().toString()),X2));
}
else
throw new IllegalStateException("Internal error: invalid normal form.");
}
else
throw new IllegalStateException("Internal error: invalid normal form.");
int yIndex=1;
// object properties always go to the body
for (OWLObjectPropertyExpression p : object.getObjectPropertyExpressions()) {
Variable y;
y=Variable.create("Y"+yIndex);
yIndex++;
bodyAtoms.add(getRoleAtom(p,X1,y));
bodyAtoms.add(getRoleAtom(p,X2,y));
// also the key criteria are named in case of object properties
bodyAtoms.add(Atom.create(AtomicConcept.INTERNAL_NAMED,y));
}
// data properties go to the body, but with different variables
// the head gets an atom asserting inequality between that data values
for (OWLDataPropertyExpression d : object.getDataPropertyExpressions()) {
Variable y;
y=Variable.create("Y"+yIndex);
yIndex++;
bodyAtoms.add(getRoleAtom(d,X1,y));
Variable y2;
y2=Variable.create("Y"+yIndex);
yIndex++;
bodyAtoms.add(getRoleAtom(d,X2,y2));
headAtoms.add(Atom.create(Inequality.INSTANCE,y,y2));
}
Atom[] hAtoms=new Atom[headAtoms.size()];
headAtoms.toArray(hAtoms);
Atom[] bAtoms=new Atom[bodyAtoms.size()];
bodyAtoms.toArray(bAtoms);
DLClause clause=DLClause.create(hAtoms,bAtoms);
return clause;
}
protected static LiteralConcept getLiteralConcept(OWLClassExpression description) {
if (description instanceof OWLClass) {
return AtomicConcept.create(((OWLClass)description).getIRI().toString());
}
else if (description instanceof OWLObjectComplementOf) {
OWLClassExpression internal=((OWLObjectComplementOf)description).getOperand();
if (!(internal instanceof OWLClass))
throw new IllegalStateException("Internal error: invalid normal form.");
return AtomicConcept.create(((OWLClass)internal).getIRI().toString()).getNegation();
}
else
throw new IllegalStateException("Internal error: invalid normal form.");
}
protected static Role getRole(OWLObjectPropertyExpression objectPropertyExpression) {
objectPropertyExpression=objectPropertyExpression.getSimplified();
if (objectPropertyExpression instanceof OWLObjectProperty)
return AtomicRole.create(((OWLObjectProperty)objectPropertyExpression).getIRI().toString());
else if (objectPropertyExpression instanceof OWLObjectInverseOf) {
OWLObjectPropertyExpression internal=((OWLObjectInverseOf)objectPropertyExpression).getInverse();
if (!(internal instanceof OWLObjectProperty))
throw new IllegalStateException("Internal error: invalid normal form.");
return AtomicRole.create(((OWLObjectProperty)internal).getIRI().toString()).getInverse();
}
else
throw new IllegalStateException("Internal error: invalid normal form.");
}
protected static AtomicRole getAtomicRole(OWLDataPropertyExpression dataPropertyExpression) {
return AtomicRole.create(((OWLDataProperty)dataPropertyExpression).getIRI().toString());
}
protected static Atom getRoleAtom(OWLObjectPropertyExpression objectProperty,Term first,Term second) {
objectProperty=objectProperty.getSimplified();
if (!objectProperty.isAnonymous()) {
AtomicRole role=AtomicRole.create(objectProperty.asOWLObjectProperty().getIRI().toString());
return Atom.create(role,first,second);
}
else if (objectProperty.isAnonymous()) {
OWLObjectProperty internalObjectProperty=objectProperty.getNamedProperty();
AtomicRole role=AtomicRole.create(internalObjectProperty.getIRI().toString());
return Atom.create(role,second,first);
}
else
throw new IllegalStateException("Internal error: unsupported type of object property!");
}
protected static Atom getRoleAtom(OWLDataPropertyExpression dataProperty,Term first,Term second) {
if (dataProperty instanceof OWLDataProperty) {
AtomicRole property=AtomicRole.create(((OWLDataProperty)dataProperty).getIRI().toString());
return Atom.create(property,first,second);
}
else
throw new IllegalStateException("Internal error: unsupported type of data property!");
}
protected static Individual getIndividual(OWLIndividual individual) {
if (individual.isAnonymous())
return Individual.createAnonymous(individual.asOWLAnonymousIndividual().getID().toString());
else
return Individual.create(individual.asOWLNamedIndividual().getIRI().toString());
}
protected static class NormalizedAxiomClausifier implements OWLClassExpressionVisitor {
protected final DataRangeConverter m_dataRangeConverter;
protected final List m_headAtoms;
protected final List m_bodyAtoms;
protected final Set m_positiveFacts;
protected final OWLDataFactory m_factory;
protected int m_yIndex;
protected int m_zIndex;
public NormalizedAxiomClausifier(DataRangeConverter dataRangeConverter,Set positiveFacts,OWLDataFactory factory) {
m_dataRangeConverter=dataRangeConverter;
m_headAtoms=new ArrayList();
m_bodyAtoms=new ArrayList();
m_positiveFacts=positiveFacts;
m_factory=factory;
}
protected DLClause getDLClause() {
Atom[] headAtoms=new Atom[m_headAtoms.size()];
m_headAtoms.toArray(headAtoms);
Atom[] bodyAtoms=new Atom[m_bodyAtoms.size()];
m_bodyAtoms.toArray(bodyAtoms);
DLClause dlClause=DLClause.create(headAtoms,bodyAtoms);
m_headAtoms.clear();
m_bodyAtoms.clear();
m_yIndex=0;
m_zIndex=0;
return dlClause;
}
protected void ensureYNotZero() {
if (m_yIndex==0)
m_yIndex++;
}
protected Variable nextY() {
Variable result;
if (m_yIndex==0)
result=Y;
else
result=Variable.create("Y"+m_yIndex);
m_yIndex++;
return result;
}
protected Variable nextZ() {
Variable result;
if (m_zIndex==0)
result=Z;
else
result=Variable.create("Z"+m_zIndex);
m_zIndex++;
return result;
}
protected AtomicConcept getConceptForNominal(OWLIndividual individual) {
AtomicConcept result;
if (individual.isAnonymous()) {
result=AtomicConcept.create("internal:anon#"+individual.asOWLAnonymousIndividual().getID().toString());
}
else {
result=AtomicConcept.create("internal:nom#"+individual.asOWLNamedIndividual().getIRI().toString());
}
m_positiveFacts.add(Atom.create(result,getIndividual(individual)));
return result;
}
// Various types of descriptions
public void visit(OWLClass object) {
m_headAtoms.add(Atom.create(AtomicConcept.create(object.getIRI().toString()),X));
}
public void visit(OWLObjectIntersectionOf object) {
throw new IllegalStateException("Internal error: invalid normal form.");
}
public void visit(OWLObjectUnionOf object) {
throw new IllegalStateException("Internal error: invalid normal form.");
}
public void visit(OWLObjectComplementOf object) {
OWLClassExpression description=object.getOperand();
if (description instanceof OWLObjectHasSelf) {
OWLObjectPropertyExpression objectProperty=((OWLObjectHasSelf)description).getProperty();
Atom roleAtom=getRoleAtom(objectProperty,X,X);
m_bodyAtoms.add(roleAtom);
}
else if (description instanceof OWLObjectOneOf && ((OWLObjectOneOf)description).getIndividuals().size()==1) {
OWLIndividual individual=((OWLObjectOneOf)description).getIndividuals().iterator().next();
m_bodyAtoms.add(Atom.create(getConceptForNominal(individual),X));
}
else if (!(description instanceof OWLClass))
throw new IllegalStateException("Internal error: invalid normal form.");
else
m_bodyAtoms.add(Atom.create(AtomicConcept.create(((OWLClass)description).getIRI().toString()),X));
}
public void visit(OWLObjectOneOf object) {
for (OWLIndividual individual : object.getIndividuals()) {
Variable z=nextZ();
AtomicConcept conceptForNominal=getConceptForNominal(individual);
m_headAtoms.add(Atom.create(Equality.INSTANCE,X,z));
m_bodyAtoms.add(Atom.create(conceptForNominal,z));
}
}
public void visit(OWLObjectSomeValuesFrom object) {
OWLClassExpression filler=object.getFiller();
if (filler instanceof OWLObjectOneOf) {
for (OWLIndividual individual : ((OWLObjectOneOf)filler).getIndividuals()) {
Variable z=nextZ();
m_bodyAtoms.add(Atom.create(getConceptForNominal(individual),z));
m_headAtoms.add(getRoleAtom(object.getProperty(),X,z));
}
}
else {
LiteralConcept toConcept=getLiteralConcept(filler);
Role onRole=getRole(object.getProperty());
AtLeastConcept atLeastConcept=AtLeastConcept.create(1,onRole,toConcept);
if (!atLeastConcept.isAlwaysFalse())
m_headAtoms.add(Atom.create(atLeastConcept,X));
}
}
public void visit(OWLObjectAllValuesFrom object) {
Variable y=nextY();
m_bodyAtoms.add(getRoleAtom(object.getProperty(),X,y));
OWLClassExpression filler=object.getFiller();
if (filler instanceof OWLClass) {
AtomicConcept atomicConcept=AtomicConcept.create(((OWLClass)filler).getIRI().toString());
if (!atomicConcept.isAlwaysFalse())
m_headAtoms.add(Atom.create(atomicConcept,y));
}
else if (filler instanceof OWLObjectOneOf) {
for (OWLIndividual individual : ((OWLObjectOneOf)filler).getIndividuals()) {
Variable zInd=nextZ();
m_bodyAtoms.add(Atom.create(getConceptForNominal(individual),zInd));
m_headAtoms.add(Atom.create(Equality.INSTANCE,y,zInd));
}
}
else if (filler instanceof OWLObjectComplementOf) {
OWLClassExpression operand=((OWLObjectComplementOf)filler).getOperand();
if (operand instanceof OWLClass) {
AtomicConcept internalAtomicConcept=AtomicConcept.create(((OWLClass)operand).getIRI().toString());
if (!internalAtomicConcept.isAlwaysTrue())
m_bodyAtoms.add(Atom.create(internalAtomicConcept,y));
}
else if (operand instanceof OWLObjectOneOf && ((OWLObjectOneOf)operand).getIndividuals().size()==1) {
OWLIndividual individual=((OWLObjectOneOf)operand).getIndividuals().iterator().next();
m_bodyAtoms.add(Atom.create(getConceptForNominal(individual),y));
}
else
throw new IllegalStateException("Internal error: invalid normal form.");
}
else
throw new IllegalStateException("Internal error: invalid normal form.");
}
public void visit(OWLObjectHasValue object) {
throw new IllegalStateException("Internal error: invalid normal form.");
}
public void visit(OWLObjectHasSelf object) {
OWLObjectPropertyExpression objectProperty=object.getProperty();
Atom roleAtom=getRoleAtom(objectProperty,X,X);
m_headAtoms.add(roleAtom);
}
public void visit(OWLObjectMinCardinality object) {
LiteralConcept toConcept=getLiteralConcept(object.getFiller());
Role onRole=getRole(object.getProperty());
AtLeastConcept atLeastConcept=AtLeastConcept.create(object.getCardinality(),onRole,toConcept);
if (!atLeastConcept.isAlwaysFalse())
m_headAtoms.add(Atom.create(atLeastConcept,X));
}
public void visit(OWLObjectMaxCardinality object) {
int cardinality=object.getCardinality();
OWLObjectPropertyExpression onObjectProperty=object.getProperty();
OWLClassExpression filler=object.getFiller();
ensureYNotZero();
boolean isPositive;
AtomicConcept atomicConcept;
if (filler instanceof OWLClass) {
isPositive=true;
atomicConcept=AtomicConcept.create(((OWLClass)filler).getIRI().toString());
if (atomicConcept.isAlwaysTrue())
atomicConcept=null;
}
else if (filler instanceof OWLObjectComplementOf) {
OWLClassExpression internal=((OWLObjectComplementOf)filler).getOperand();
if (!(internal instanceof OWLClass))
throw new IllegalStateException("Internal error: Invalid ontology normal form.");
isPositive=false;
atomicConcept=AtomicConcept.create(((OWLClass)internal).getIRI().toString());
if (atomicConcept.isAlwaysFalse())
atomicConcept=null;
}
else
throw new IllegalStateException("Internal error: Invalid ontology normal form.");
Role onRole=getRole(onObjectProperty);
LiteralConcept toConcept=getLiteralConcept(filler);
AnnotatedEquality annotatedEquality=AnnotatedEquality.create(cardinality,onRole,toConcept);
Variable[] yVars=new Variable[cardinality+1];
for (int i=0;i2) {
for (int i=0;i m_definedDatatypeIRIs;
protected final List m_headAtoms;
protected final List m_bodyAtoms;
protected final OWLDataFactory m_factory;
protected int m_yIndex;
public NormalizedDataRangeAxiomClausifier(DataRangeConverter dataRangeConverter,OWLDataFactory factory,Set definedDatatypeIRIs) {
m_dataRangeConverter=dataRangeConverter;
m_definedDatatypeIRIs=definedDatatypeIRIs;
m_headAtoms=new ArrayList();
m_bodyAtoms=new ArrayList();
m_factory=factory;
}
protected DLClause getDLClause() {
Atom[] headAtoms=new Atom[m_headAtoms.size()];
m_headAtoms.toArray(headAtoms);
Atom[] bodyAtoms=new Atom[m_bodyAtoms.size()];
m_bodyAtoms.toArray(bodyAtoms);
DLClause dlClause=DLClause.create(headAtoms,bodyAtoms);
m_headAtoms.clear();
m_bodyAtoms.clear();
m_yIndex=0;
return dlClause;
}
protected void ensureYNotZero() {
if (m_yIndex==0)
m_yIndex++;
}
protected Variable nextY() {
Variable result;
if (m_yIndex==0)
result=Y;
else
result=Variable.create("Y"+m_yIndex);
m_yIndex++;
return result;
}
// Various types of descriptions
public void visit(OWLDatatype dt) {
LiteralDataRange literalRange=m_dataRangeConverter.convertDataRange(dt);
m_headAtoms.add(Atom.create((DLPredicate)literalRange,X));
}
public void visit(OWLDataIntersectionOf dr) {
throw new IllegalStateException("Internal error: invalid normal form.");
}
public void visit(OWLDataUnionOf dr) {
throw new IllegalStateException("Internal error: invalid normal form.");
}
public void visit(OWLDataComplementOf dr) {
OWLDataRange description=dr.getDataRange();
if (description.isDatatype() && (Prefixes.isInternalIRI(description.asOWLDatatype().getIRI().toString()) || m_definedDatatypeIRIs.contains(description.asOWLDatatype()))) {
m_bodyAtoms.add(Atom.create(InternalDatatype.create(description.asOWLDatatype().getIRI().toString()),X));
}
else {
LiteralDataRange literalRange=m_dataRangeConverter.convertDataRange(dr);
if (literalRange.isNegatedInternalDatatype()) {
InternalDatatype negatedDatatype=(InternalDatatype)literalRange.getNegation();
if (!negatedDatatype.isAlwaysTrue())
m_bodyAtoms.add(Atom.create(negatedDatatype,X));
}
else {
if (!literalRange.isAlwaysFalse())
m_headAtoms.add(Atom.create((DLPredicate)literalRange,X));
}
}
}
public void visit(OWLDataOneOf object) {
LiteralDataRange literalRange=m_dataRangeConverter.convertDataRange(object);
m_headAtoms.add(Atom.create((DLPredicate)literalRange,X));
}
public void visit(OWLFacetRestriction node) {
throw new IllegalStateException("Internal error: Invalid normal form. ");
}
public void visit(OWLDatatypeRestriction node) {
LiteralDataRange literalRange=m_dataRangeConverter.convertDataRange(node);
m_headAtoms.add(Atom.create((DLPredicate)literalRange,X));
}
public void visit(OWLLiteral node) {
throw new IllegalStateException("Internal error: Invalid normal form. ");
}
}
protected static class DataRangeConverter implements OWLDataVisitorEx © 2015 - 2025 Weber Informatics LLC | Privacy Policy