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 void	computeRoleCombinations(Set<Var> vars, Set<Role> roles, Map<Var,VarPattern> roleMap, Set<Map<Var,VarPattern>> roleMaps) compute all rolePlayer-roleType combinations complementing provided roleMap
static Rule	createPropertyChainRule(String label, RelationshipType relation, Label fromRoleLabel, Label toRoleLabel, LinkedHashMap<RelationshipType,Pair<Label,Label>> chain, GraknTx tx) creates rule R(fromRole: x, toRole: xm) :- R1(fromRole: x, ...), , R2, ...
static Rule	createReflexiveRule(String label, RelationshipType relType, Label fromRoleLabel, Label toRoleLabel, GraknTx tx) create reflexive rule R(from: X, to: X) :- R(from: X,to: Y)
static Rule	createSubPropertyRule(String label, RelationshipType parent, RelationshipType child, Map<Label,Label> roleMappings, GraknTx tx) creates rule parent :- child
static Rule	createTransitiveRule(String label, RelationshipType relType, Label fromRoleLabel, Label toRoleLabel, GraknTx tx) create transitive Rule R(from: X, to: Y) :- R(from: X,to: Z), R(from: Z, to: Y)
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 <T> List<List<T>>	getListPermutations(List<T> entryList) get all permutations of an entry list
static Set<Unifier>	getUnifiersFromPermutations(List<Pair<Var,Var>> originalVars, List<List<Pair<Var,Var>>> permutations) get unifiers by comparing permutations with original variables
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 extends Predicate> boolean	predicatesCompatible(T parent, T child, boolean exact)
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 Type	top(Type type)
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

getUnifiersFromPermutations

public static Set<Unifier> getUnifiersFromPermutations(List<Pair<Var,Var>> originalVars,
                                                       List<List<Pair<Var,Var>>> permutations)

get unifiers by comparing permutations with original variables

Parameters:

originalVars - original ordered variables

permutations - different permutations on the variables

Returns:

set of unifiers

getListPermutations

public static <T> List<List<T>> getListPermutations(List<T> entryList)

get all permutations of an entry list

Type Parameters:

T - element type

Parameters:

entryList - entry list to generate permutations of

Returns:

set of all possible permutations

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

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 set

Returns:

top non-meta SchemaConcepts from within the provided set of Role

top

public static Type top(Type type)

Parameters:

type - for which top type is to be found

Returns:

non-meta top type of the type

computeRoleCombinations

public static void computeRoleCombinations(Set<Var> vars,
                                           Set<Role> roles,
                                           Map<Var,VarPattern> roleMap,
                                           Set<Map<Var,VarPattern>> roleMaps)

compute all rolePlayer-roleType combinations complementing provided roleMap

Parameters:

vars - set of rolePlayers

roles - set of roleTypes

roleMap - initial rolePlayer-roleType roleMap to be complemented

roleMaps - output set containing possible role mappings complementing the roleMap configuration

createTransitiveRule

public static Rule createTransitiveRule(String label,
                                        RelationshipType relType,
                                        Label fromRoleLabel,
                                        Label toRoleLabel,
                                        GraknTx tx)

create transitive Rule R(from: X, to: Y) :- R(from: X,to: Z), R(from: Z, to: Y)

Parameters:

label - the Label of the new Rule to create

relType - transitive RelationshipType

fromRoleLabel - from directional Role Label

toRoleLabel - to directional Role Label

tx - for the Rule to be inserted

Returns:

the new Rule

createReflexiveRule

public static Rule createReflexiveRule(String label,
                                       RelationshipType relType,
                                       Label fromRoleLabel,
                                       Label toRoleLabel,
                                       GraknTx tx)

create reflexive rule R(from: X, to: X) :- R(from: X,to: Y)

Parameters:

label - the Label of the new Rule to create

relType - reflexive RelationshipType

fromRoleLabel - from directional Role Label

toRoleLabel - to directional Role Label

tx - for the Rule to be inserted

Returns:

the new Rule

createSubPropertyRule

public static Rule createSubPropertyRule(String label,
                                         RelationshipType parent,
                                         RelationshipType child,
                                         Map<Label,Label> roleMappings,
                                         GraknTx tx)

creates rule parent :- child

Parameters:

label - the Label of the new Rule to create

parent - RelationshipType of parent

child - RelationshipType of child

roleMappings - map of corresponding Role names

tx - for the Rule to be inserted

Returns:

the new Rule

createPropertyChainRule

public static Rule createPropertyChainRule(String label,
                                           RelationshipType relation,
                                           Label fromRoleLabel,
                                           Label toRoleLabel,
                                           LinkedHashMap<RelationshipType,Pair<Label,Label>> chain,
                                           GraknTx tx)

creates rule R(fromRole: x, toRole: xm) :- R1(fromRole: x, ...), , R2, ... , Rn(..., toRole: xm)

Parameters:

label - the Label of the new Rule to create

relation - head RelationshipType

fromRoleLabel - specifies the Role directionality of the head RelationshipType

toRoleLabel - specifies the Role directionality of the head RelationshipType

chain - map containing ordered relation with their corresponding Role mappings

tx - for the Rule to be inserted

Returns:

the new Rule

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

predicatesCompatible

public static <T extends Predicate> boolean predicatesCompatible(T parent,
                                                                 T child,
                                                                 boolean exact)

Type Parameters:

T - type generic

Parameters:

parent - predicate

child - predicate

exact - whether compatibility criterion should be exact

Returns:

true if predicates compatible

areDisjointTypes

public static boolean areDisjointTypes(SchemaConcept parent,
                                       SchemaConcept child)

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

Parameters:

parent - type

child - type

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.