Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package it.unibz.krdb.obda.owlrefplatform.core.reformulation;
  
  /*
   * #%L
   * ontop-reformulation-core
   * %%
   * Copyright (C) 2009 - 2014 Free University of Bozen-Bolzano
   * %%
   * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * #L%
  */
 
 
 import java.util.Map;
 import java.util.Set;
 
TreeWitnessReasonerLite a simple reasoner for DL-Lite that computes and gives - subconcepts for a given concept - subproperties for a given property

Author(s):
Roman Kontchakov
 
 
 
 public class TreeWitnessReasonerLite {
 	private Ontology tbox;
 
 	// reflexive and transitive closure of the relations
 
 	// caching for predicate symbols 
 
 	// tree witness generators of the ontology (i.e., positive occurrences of \exists R.B)
 
 	private static final OntologyFactory ontFactory = OntologyFactoryImpl.getInstance();
 	private static final Logger log = LoggerFactory.getLogger(TreeWitnessReasonerLite.class);	
 
 	public static final OClass owlThing = .createClass("http://www.w3.org/TR/2004/REC-owl-semantics-20040210/#owl_Thing");	
 	
 		return ;
 	}
 	
 	public void setTBox(Ontology ontology) {
 
 		this. = ontology;
 		.debug("SET ONTOLOGY {}"ontology);
 
 		
 		
		// COLLECT GENERATING CONCEPTS (together with their declared subclasses)
		// COLLECT SUB-CONCEPT AND SUB-PROPERTY RELATIONS
		.debug("AXIOMS");
		for (Axiom ax : .getAssertions()) {
			if (ax instanceof SubClassAxiomImpl) {
				.debug("CI AXIOM: {}"sax);
				ClassDescription superConcept = sax.getSuper();
				if (superConcept instanceof PropertySomeClassRestriction) {
					// make \exists R.\top equivalent to \exists R
					if (some.getFiller().equals()) 
					TreeWitnessGenerator twg = gens.get(superConcept);
					if (twg == null) {
						gens.put(superConcepttwg);
					}
					twg.addConcept(subConcept);
					.debug("GENERATING CI: {} <= {}"subConceptsuperConcept);
				}
				else {
					BasicClassDescription basicSuperConcept = (BasicClassDescription)superConcept;
					Set<BasicClassDescriptionset = .get(basicSuperConcept);
					if (set == null) {
						set.add(basicSuperConcept);  // keep it reflexive
						.put(basicSuperConceptset);
					}
					set.add(subConcept);	
					if (basicSuperConcept instanceof PropertySomeRestriction) {
						TreeWitnessGenerator twg = gens.get(some);
						if (twg == null) {
							gens.put(superConcepttwg);
						}
						twg.addConcept(subConcept);
						.debug("GENERATING CI: {} <= {}"subConceptsome);
					}
				}
			else if (ax instanceof SubPropertyAxiomImpl) {
				.debug("RI AXIOM: {}"sax);
				Property superProperty = sax.getSuper();
				Property subProperty = sax.getSub();
				Property superPropertyInv = .createProperty(superProperty.getPredicate(), !superProperty.isInverse());
				Property subPropertyInv = .createProperty(subProperty.getPredicate(), !subProperty.isInverse());
				Set<Propertyset = .get(superProperty);
				Set<PropertysetInv = null;
				if (set == null) {
					set = new HashSet<Property>(4);
					set.add(superProperty);  // keep it reflexive
					set.add(subProperty);
					.put(superPropertyset);
					setInv = new HashSet<Property>(4);
					setInv.add(superPropertyInv); // keep it reflexive
					setInv.add(subPropertyInv);
					.put(superPropertyInvsetInv);
				}
				else 
					setInv = .get(superPropertyInv);
				set.add(subProperty);
				setInv.add(subPropertyInv);
			}
			else
				.debug("UNKNOWN AXIOM TYPE: {}"ax);
		}
		 = gens.values();
		// SATURATE PROPERTY HIERARCHY
		{
				.debug("DECLARED SUBPROPERTIES OF {} ARE {}"p.getKey(), p.getValue());
				.debug("SATURATED SUBPROPERTY OF {} ARE {}"p.getKey(), p.getValue());
		}
		// SATURATE CONCEPT HIERARCHY
		{
				.debug("DECLARED SUBCONCEPTS OF {} ARE {}"k.getKey(), k.getValue());
			// ADD INCLUSIONS BETWEEN EXISTENTIALS OF SUB-PROPERTIES
				Set<BasicClassDescriptionsetExistsSuper = .get(existsSuper);
				if (setExistsSuper == null) {
					setExistsSuper = new HashSet<BasicClassDescription>();
					// no need to insert reflexive pair as the role hierarchy is already reflexive
					.put(existsSupersetExistsSuper); 
				}
				for (Property subproperty : prop.getValue()) 
					setExistsSuper.add(.createPropertySomeRestriction(subproperty.getPredicate(), subproperty.isInverse())); 	
			}
				.debug("SATURATED SUBCONCEPTS OF {} ARE {}"k.getKey(), k.getValue());
		}
	}
	private static <T> void graphTransitiveClosure(Map<T, Set<T>> graph) {
		.debug("COMPUTING TRANSITIVE CLOSURE");
		Queue<T> useForExtension = new LinkedList<T>(graph.keySet());
		while (!useForExtension.isEmpty()) {
o1key = useForExtension.poll();
			//log.debug("   USE FOR EXTENSION: " + o1key);
			Set<T> o1value = null;
			for (Map.Entry<T, Set<T>> o2 : graph.entrySet()) {
				if (o2.getKey() == o1key)
					continue;
				if (o2.getValue().contains(o1key)) {
					if (o1value == null)
						o1value = graph.get(o1key);
					if (o2.getValue().addAll(o1value)) {
						useForExtension.add(o2.getKey());
						//log.debug("ALL " + o2.getKey() + " ARE EXTENDED WITH ALL " + o1key);
					}
				}
			}
		}		
	}

getSubConcepts

Parameters:
con is a basic class description (concept name or \exists R)
Returns:
the set of subsconcepts of B
		if (s == null) {
			s = Collections.singleton(con);
			.put(cons);
		}
		return s;
	}
		if (s == null) {
		}
		return s;
	}
		for (Function a : atoms) {
			 if (a.getArity() != 1)
				 return .;   // binary predicates R(x,x) cannot be matched to the anonymous part
		}
		return subc;
	}


getSubproperties

Parameters:
prop is a property (property name or its inverse)
Returns:
the set of subproperties
		if (s == null) {
			s = Collections.singleton(prop);
			.put(props);
		}
		return s;
	}
	}
	public Set<PropertygetSubProperties(Predicate predboolean inverse) {
		Set<Propertys = cache.get(pred);
		if (s == null) {
			cache.put(preds);
		}
		return s;
	}
	public boolean isMoreSpecific(Function a1Function a2) {
		if (a1 == a2 || a1.equals(a2))
			return true;
		if ((a2.getArity() == 1) && (a1.getArity() == 1)) {
			if (a1.getTerm(0).equals(a2.getTerm(0))) {
					.debug("{} IS MORE SPECIFIC (1-1) THAN {}"a1a2);
					return true;
				}
			}
		}
		else if ((a1.getArity() == 2) && (a2.getArity() == 1)) { // MOST USEFUL
			Term a2term = a2.getTerm(0);
			if (a1.getTerm(0).equals(a2term)) {
					.debug("{} IS MORE SPECIFIC (2-1) THAN "a1a2);
					return true;
				}
			}
			if (a1.getTerm(1).equals(a2term)) {
					.debug("{} IS MORE SPECIFIC (2-1) THAN {}"a1a2);
					return true;
				}
			}
		}
		// TODO: implement the (2-2) check
		return false;
	}


getGenerators

Returns:
the collection of all tree witness generators for the ontology
		return ;
	}



computes intersections of sets of properties internal representation: the downward-saturated set of properties (including all sub-properties)

Author(s):
roman
	public static class IntersectionOfProperties {
		private Set<Propertyset;
		}
			 = (set2 == null) ? null : new HashSet<Property>(set2);
		}
		public boolean intersect(Set<Propertysubp) {
			if ( == null// first atom
				 = new HashSet<Property>(subp);
			else
			if (.isEmpty()) {
				return false;
			}
			else
				return true;
		}
		public void clear() {
			 = null;
		}
		public Set<Propertyget() {
			return ;
		}
		public String toString() {
			return (( == null) ? "properties TOP" : "properties " + .toString());
		}
	}
	public static class IntersectionOfConceptSets {
		}
			 = (subc == null) ?  null : (subc.isEmpty() ? . : new HashSet<BasicClassDescription>(subc));
		}
			this(s2.set);
		}
		public boolean intersect(IntersectionOfConceptSets subc) {
			// null denotes \top
			if (subc.set == null
				return !isEmpty();
			return intersect(subc.set);
		}	
		public boolean intersect(Set<BasicClassDescriptionsubc) {
			// intersection with the empty set is empty
			if (subc.isEmpty()) {
				return false;
			}
			if ( == null) { // the intersection has not been initialised
				return true;
			}
			if (.isEmpty()) {
				return false;
			}
			return true;
		}	
		public boolean isEmpty() {
			return (( != null) && .isEmpty());
		}
			return ;
		}
		public void clear() {
			 = null;
		}
	}	
New to GrepCode? Check out our FAQ X