ai.grakn.graql.internal.reasoner.utils

Class ReasonerUtils

java.lang.Object

ai.grakn.graql.internal.reasoner.utils.ReasonerUtils

public class ReasonerUtils
extends Object

Utiliy class providing useful functionalities.

Author:

Kasper Piskorski

Constructor Summary

Constructors

Constructor and Description
ReasonerUtils()

Method Summary

Modifier and Type	Method and Description
static boolean	areDisjointTypes(SchemaConcept parent, SchemaConcept child) determines disjointness of parent-child types, parent defines the bound on the child
static <T extends SchemaConcept> com.google.common.collect.Multimap<RelationshipType,Role>	compatibleRelationTypesWithRoles(Set<T> types, SchemaConceptConverter<T> schemaConceptConverter) NB: assumes MATCH semantics - all types and their subs are considered compute the map of compatible RelationshipTypes for a given set of Types (intersection of allowed sets of relation types for each entry type) and compatible role types
static Set<Role>	compatibleRoles(Role parentRole, Type parentType, Set<Role> entryRoles) NB: assumes MATCH semantics - all types and their subs are considered
static Set<Role>	compatibleRoles(Type type, Set<Role> relRoles)
static IdPredicate	getIdPredicate(Var typeVariable, VarPatternAdmin typeVar, Set<VarPatternAdmin> vars, ReasonerQuery parent) looks for an appropriate var property with a specified name among the vars and maps it to an IdPredicate, covers both the cases when variable is and isn't user defined
static IdPredicate	getUserDefinedIdPredicate(Var typeVariable, Set<VarPatternAdmin> vars, ReasonerQuery parent) looks for an appropriate var property with a specified name among the vars and maps it to an IdPredicate, covers the case when specified variable name is user defined
static Set<ValuePredicate>	getValuePredicates(Var valueVariable, VarPatternAdmin valueVar, Set<VarPatternAdmin> vars, ReasonerQuery parent) looks for appropriate var properties with a specified name among the vars and maps them to ValuePredicates, covers both the case when variable is and isn't user defined
static <K,V> com.google.common.collect.Multimap<K,V>	multimapIntersection(com.google.common.collect.Multimap<K,V> m1, com.google.common.collect.Multimap<K,V> m2) calculates map intersection by doing an intersection on key sets and accumulating the keys
static <T> Collection<T>	subtract(Collection<T> a, Collection<T> b)
static Set<SchemaConcept>	supers(SchemaConcept schemaConcept)
static <T extends SchemaConcept> Set<T>	top(Set<T> schemaConcepts)
static <T extends SchemaConcept> Set<T>	topOrMeta(Set<T> schemaConcepts)
static boolean	typesCompatible(SchemaConcept parent, SchemaConcept child)
static Unifier	typeUnifier(Set<TypeAtom> childTypes, Set<TypeAtom> parentTypes, Unifier childParentUnifier)
static Set<SchemaConcept>	upstreamHierarchy(SchemaConcept concept)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ReasonerUtils

public ReasonerUtils()

Method Detail

getUserDefinedIdPredicate

public static IdPredicate getUserDefinedIdPredicate(Var typeVariable,
                                                    Set<VarPatternAdmin> vars,
                                                    ReasonerQuery parent)

looks for an appropriate var property with a specified name among the vars and maps it to an IdPredicate, covers the case when specified variable name is user defined

Parameters:

typeVariable - variable name of interest

vars - VarAdmins to look for properties

parent - reasoner query the mapped predicate should belong to

Returns:

mapped IdPredicate

getIdPredicate

@Nullable
public static IdPredicate getIdPredicate(Var typeVariable,
                                                   VarPatternAdmin typeVar,
                                                   Set<VarPatternAdmin> vars,
                                                   ReasonerQuery parent)

looks for an appropriate var property with a specified name among the vars and maps it to an IdPredicate, covers both the cases when variable is and isn't user defined

Parameters:

typeVariable - variable name of interest

typeVar - VarPatternAdmin to look for in case the variable name is not user defined

vars - VarAdmins to look for properties

parent - reasoner query the mapped predicate should belong to

Returns:

mapped IdPredicate

getValuePredicates

public static Set<ValuePredicate> getValuePredicates(Var valueVariable,
                                                     VarPatternAdmin valueVar,
                                                     Set<VarPatternAdmin> vars,
                                                     ReasonerQuery parent)

looks for appropriate var properties with a specified name among the vars and maps them to ValuePredicates, covers both the case when variable is and isn't user defined

Parameters:

valueVariable - variable name of interest

valueVar - VarPatternAdmin to look for in case the variable name is not user defined

vars - VarAdmins to look for properties

parent - reasoner query the mapped predicate should belong to

Returns:

set of mapped ValuePredicates

supers

public static Set<SchemaConcept> supers(SchemaConcept schemaConcept)

Parameters:

schemaConcept - input type

Returns:

set of all non-meta super types of the role

upstreamHierarchy

public static Set<SchemaConcept> upstreamHierarchy(SchemaConcept concept)

Parameters:

concept - which hierarchy should be considered

Returns:

set of SchemaConcepts consisting of the provided SchemaConcept and all its supers including meta

multimapIntersection

public static <K,V> com.google.common.collect.Multimap<K,V> multimapIntersection(com.google.common.collect.Multimap<K,V> m1,
                                                                                 com.google.common.collect.Multimap<K,V> m2)

calculates map intersection by doing an intersection on key sets and accumulating the keys

Type Parameters:

K - map key type

V - map value type

Parameters:

m1 - first operand

m2 - second operand

Returns:

map intersection

compatibleRelationTypesWithRoles

public static <T extends SchemaConcept> com.google.common.collect.Multimap<RelationshipType,Role> compatibleRelationTypesWithRoles(Set<T> types,
                                                                                                                                   SchemaConceptConverter<T> schemaConceptConverter)

NB: assumes MATCH semantics - all types and their subs are considered compute the map of compatible RelationshipTypes for a given set of Types (intersection of allowed sets of relation types for each entry type) and compatible role types

Type Parameters:

T - type generic

Parameters:

types - for which the set of compatible RelationshipTypes is to be computed

schemaConceptConverter - converter between SchemaConcept and relation type-role entries

Returns:

map of compatible RelationshipTypes and their corresponding Roles

compatibleRoles

public static Set<Role> compatibleRoles(Role parentRole,
                                        Type parentType,
                                        Set<Role> entryRoles)

NB: assumes MATCH semantics - all types and their subs are considered

Parameters:

parentRole - parent Role

parentType - parent Type

entryRoles - entry set of possible Roles

Returns:

set of playable Roles defined by type-role parent combination, parent role assumed as possible

compatibleRoles

public static Set<Role> compatibleRoles(Type type,
                                        Set<Role> relRoles)

top

public static <T extends SchemaConcept> Set<T> top(Set<T> schemaConcepts)

Parameters:

schemaConcepts - entry SchemaConcept set

Returns:

top non-meta SchemaConcepts from within the provided set

topOrMeta

public static <T extends SchemaConcept> Set<T> topOrMeta(Set<T> schemaConcepts)

Parameters:

schemaConcepts - entry SchemaConcept set

Returns:

top SchemaConcepts from within the provided set or meta concept if it exists

typeUnifier

public static Unifier typeUnifier(Set<TypeAtom> childTypes,
                                  Set<TypeAtom> parentTypes,
                                  Unifier childParentUnifier)

Parameters:

childTypes - type atoms of child query

parentTypes - type atoms of parent query

childParentUnifier - unifier to unify child with parent

Returns:

combined unifier for type atoms

typesCompatible

public static boolean typesCompatible(SchemaConcept parent,
                                      SchemaConcept child)

Parameters:

parent - type

child - type

Returns:

true if child is a subtype of parent

areDisjointTypes

public static boolean areDisjointTypes(SchemaConcept parent,
                                       SchemaConcept child)

determines disjointness of parent-child types, parent defines the bound on the child

Parameters:

parent - SchemaConcept

child - SchemaConcept

Returns:

true if types do not belong to the same type hierarchy, also true if parent is null and false if parent non-null and child null

subtract

public static <T> Collection<T> subtract(Collection<T> a,
                                         Collection<T> b)

Type Parameters:

T - collection type

Parameters:

a - subtraction left operand

b - subtraction right operand

Returns:

new Collection containing a minus a - b. The cardinality of each element e in the returned Collection will be the cardinality of e in a minus the cardinality of e in b, or zero, whichever is greater.