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 Var	capture(Var var) Capture a variable name, by prepending a constant to the name
static boolean	checkTypesCompatible(Type parent, Type child)
static boolean	checkTypesDisjoint(Type parent, Type child)
static void	computeRoleCombinations(Set<Var> vars, Set<RoleType> roles, Map<Var,VarPattern> roleMap, Set<Map<Var,VarPattern>> roleMaps) compute all rolePlayer-roleType combinations complementing provided roleMap
static Rule	createPropertyChainRule(RelationType relation, TypeLabel fromRoleLabel, TypeLabel toRoleLabel, LinkedHashMap<RelationType,javafx.util.Pair<TypeLabel,TypeLabel>> chain, GraknGraph graph) creates rule R(fromRole: x, toRole: xm) :- R1(fromRole: x, ...), , R2, ...
static Rule	createReflexiveRule(RelationType relType, TypeLabel fromRoleLabel, TypeLabel toRoleLabel, GraknGraph graph) create reflexive rule R(from: X, to: X) :- R(from: X,to: Y)
static Rule	createSubPropertyRule(RelationType parent, RelationType child, Map<TypeLabel,TypeLabel> roleMappings, GraknGraph graph) creates rule parent :- child
static Rule	createTransitiveRule(RelationType relType, TypeLabel fromRoleLabel, TypeLabel toRoleLabel, GraknGraph graph) create transitive rule R(from: X, to: Y) :- R(from: X,to: Z), R(from: Z, to: Y)
static <T extends Type> com.google.common.collect.Multimap<RelationType,RoleType>	getCompatibleRelationTypesWithRoles(Set<T> types, TypeConverter<T> typeConverter) compute the map of compatible relation types for given types (intersection of allowed sets of relation types for each entry type) and compatible role types
static Set<RoleType>	getCompatibleRoleTypes(Type type, Set<RoleType> relRoles) Gets roletypes a given type can play in the provided relType relation type by performing type intersection between type's playedRoles and relation's relates.
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<Rule>	getRules(GraknGraph graph)
static Set<Type>	getSuperTypes(Type type)
static Type	getTopType(Type type)
static <T extends Type> Set<T>	getTopTypes(Set<T> types)
static Set<Unifier>	getUnifiersFromPermutations(List<Var> originalVars, List<List<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 boolean	hasRules(GraknGraph graph)
static boolean	isCaptured(Var var) Check if a variable has been captured
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 Var	uncapture(Var var) Uncapture a variable name, by removing a prepended constant

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

getRules

public static Set<Rule> getRules(GraknGraph graph)

Parameters:

graph - to be checked against

Returns:

set of inference rule contained in the graph

hasRules

public static boolean hasRules(GraknGraph graph)

Parameters:

graph - to be checked against

Returns:

true if at least one inference rule is present in the graph

capture

public static Var capture(Var var)

Capture a variable name, by prepending a constant to the name

Parameters:

var - the variable name to capture

Returns:

the captured variable

uncapture

public static Var uncapture(Var var)

Uncapture a variable name, by removing a prepended constant

Parameters:

var - the variable name to uncapture

Returns:

the uncaptured variable

isCaptured

public static boolean isCaptured(Var var)

Check if a variable has been captured

Parameters:

var - the variable to check

Returns:

if the variable has been captured

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

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<Var> originalVars,
                                                       List<List<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

getSuperTypes

public static Set<Type> getSuperTypes(Type type)

Parameters:

type - input type

Returns:

set of all non-meta super types of the role

getTopType

public static Type getTopType(Type type)

Parameters:

type - for which top type is to be found

Returns:

non-meta top type of the type

getTopTypes

public static <T extends Type> Set<T> getTopTypes(Set<T> types)

Parameters:

types - entry type set

Returns:

top non-meta types from within the provided set of role types

getCompatibleRoleTypes

public static Set<RoleType> getCompatibleRoleTypes(Type type,
                                                   Set<RoleType> relRoles)

Gets roletypes a given type can play in the provided relType relation type by performing type intersection between type's playedRoles and relation's relates.

Parameters:

type - for which we want to obtain compatible roles it plays

relRoles - relation type of interest

Returns:

set of role types the type can play in relType

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

getCompatibleRelationTypesWithRoles

public static <T extends Type> com.google.common.collect.Multimap<RelationType,RoleType> getCompatibleRelationTypesWithRoles(Set<T> types,
                                                                                                                             TypeConverter<T> typeConverter)

compute the map of compatible relation types for given 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 relation types is to be computed //* @param typeMapper function mapping a type to the set of compatible relation types

Returns:

map of compatible relation types and their corresponding role types

computeRoleCombinations

public static void computeRoleCombinations(Set<Var> vars,
                                           Set<RoleType> 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(RelationType relType,
                                        TypeLabel fromRoleLabel,
                                        TypeLabel toRoleLabel,
                                        GraknGraph graph)

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

Parameters:

relType - transitive relation type

fromRoleLabel - from directional role type type label

toRoleLabel - to directional role type type label

graph - graph for the rule to be inserted

Returns:

rule instance

createReflexiveRule

public static Rule createReflexiveRule(RelationType relType,
                                       TypeLabel fromRoleLabel,
                                       TypeLabel toRoleLabel,
                                       GraknGraph graph)

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

Parameters:

relType - reflexive relation type

fromRoleLabel - from directional role type type label

toRoleLabel - to directional role type type label

graph - graph for the rule to be inserted

Returns:

rule instance

createSubPropertyRule

public static Rule createSubPropertyRule(RelationType parent,
                                         RelationType child,
                                         Map<TypeLabel,TypeLabel> roleMappings,
                                         GraknGraph graph)

creates rule parent :- child

Parameters:

parent - relation type of parent

child - relation type of child

roleMappings - map of corresponding role type type names

graph - graph for the rule to be inserted

Returns:

rule instance

createPropertyChainRule

public static Rule createPropertyChainRule(RelationType relation,
                                           TypeLabel fromRoleLabel,
                                           TypeLabel toRoleLabel,
                                           LinkedHashMap<RelationType,javafx.util.Pair<TypeLabel,TypeLabel>> chain,
                                           GraknGraph graph)

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

Parameters:

relation - head relation

fromRoleLabel - specifies the role directionality of the head relation

toRoleLabel - specifies the role directionality of the head relation

chain - map containing ordered relation with their corresponding role mappings

graph - graph for the rule to be inserted

Returns:

rule instance

checkTypesCompatible

public static boolean checkTypesCompatible(Type parent,
                                           Type child)

Parameters:

parent - type

child - type

Returns:

true if child is a subtype of parent

checkTypesDisjoint

public static boolean checkTypesDisjoint(Type parent,
                                         Type child)

Parameters:

parent - type

child - type

Returns:

true if types do not belong to the same type hierarchy