ai.grakn.graql.internal.reasoner

Class Utility

java.lang.Object

ai.grakn.graql.internal.reasoner.Utility

public class Utility
extends Object

Utiliy class providing useful

Author:

Kasper Piskorski

Field Summary

Fields

Modifier and Type	Field and Description
static java.util.function.Function<RoleType,Set<RelationType>>	roleToRelationTypes
static java.util.function.Function<Type,Set<RelationType>>	typeToRelationTypes

Constructor Summary

Constructors

Constructor and Description
Utility()

Method Summary

Modifier and Type	Method and Description
static VarName	capture(VarName var) Capture a variable name, by prepending a constant to the name
static boolean	checkTypesCompatible(Type parent, Type child)
static void	computeRoleCombinations(Set<VarName> vars, Set<RoleType> roles, Map<VarName,Var> roleMap, Set<Map<VarName,Var>> roleMaps) compute all rolePlayer-roleType combinations complementing provided roleMap
static VarName	createFreshVariable(Set<VarName> vars, VarName var) generate a fresh variable avoiding global variables and variables from the same query
static Rule	createPropertyChainRule(RelationType relation, TypeName fromRoleName, TypeName toRoleName, LinkedHashMap<RelationType,javafx.util.Pair<TypeName,TypeName>> chain, GraknGraph graph) creates rule R(fromRole: x, toRole: xm) :- R1(fromRole: x, ...), , R2, ...
static Rule	createReflexiveRule(RelationType relType, GraknGraph graph) create reflexive rule R(from: X, to: X) :- R(from: X,to: Y)
static Rule	createSubPropertyRule(RelationType parent, RelationType child, Map<TypeName,TypeName> roleMappings, GraknGraph graph) creates rule parent :- child
static Rule	createTransitiveRule(RelationType relType, TypeName fromRoleName, TypeName toRoleName, GraknGraph graph) create transitive rule R(from: X, to: Y) :- R(from: X,to: Z), R(from: Z, to: Y)
static <T extends Type> Set<RelationType>	getCompatibleRelationTypes(Set<T> types, java.util.function.Function<T,Set<RelationType>> typeMapper)
static Set<RoleType>	getCompatibleRoleTypes(Type type, Type relType) Gets roletypes a given type can play in the provided relType relation type by performing type intersection between type's playedRoles and relation's hasRoles.
static IdPredicate	getIdPredicate(VarName typeVariable, VarAdmin typeVar, Set<VarAdmin> 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 RoleType	getNonMetaTopRole(RoleType role)
static Set<Map<VarName,VarName>>	getUnifiersFromPermutations(List<VarName> originalVars, List<List<VarName>> permutations) get unifiers by comparing permutations with original variables
static IdPredicate	getUserDefinedIdPredicate(VarName typeVariable, Set<VarAdmin> 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<Predicate>	getValuePredicates(VarName valueVariable, VarAdmin valueVar, Set<VarAdmin> 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	isCaptured(VarName var) Check if a variable has been captured
static void	printAnswers(Set<Map<String,Concept>> answers) Provides more readable answer output.
static VarName	uncapture(VarName 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

Field Detail

roleToRelationTypes

public static final java.util.function.Function<RoleType,Set<RelationType>> roleToRelationTypes

typeToRelationTypes

public static final java.util.function.Function<Type,Set<RelationType>> typeToRelationTypes

Constructor Detail

Utility

public Utility()

Method Detail

capture

public static VarName capture(VarName 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 VarName uncapture(VarName 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(VarName 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(VarName typeVariable,
                                                    Set<VarAdmin> 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(VarName typeVariable,
                                         VarAdmin typeVar,
                                         Set<VarAdmin> 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 - VarAdmin 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<Predicate> getValuePredicates(VarName valueVariable,
                                                VarAdmin valueVar,
                                                Set<VarAdmin> 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 - VarAdmin 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

printAnswers

public static void printAnswers(Set<Map<String,Concept>> answers)

Provides more readable answer output.

Parameters:

answers - set of answers to be printed

getUnifiersFromPermutations

public static Set<Map<VarName,VarName>> getUnifiersFromPermutations(List<VarName> originalVars,
                                                                    List<List<VarName>> 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

getCompatibleRoleTypes

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

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

Parameters:

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

relType - relation type of interest

Returns:

set of role types the type can play in relType

getCompatibleRelationTypes

public static <T extends Type> Set<RelationType> getCompatibleRelationTypes(Set<T> types,
                                                                            java.util.function.Function<T,Set<RelationType>> typeMapper)

computeRoleCombinations

public static void computeRoleCombinations(Set<VarName> vars,
                                           Set<RoleType> roles,
                                           Map<VarName,Var> roleMap,
                                           Set<Map<VarName,Var>> 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

createFreshVariable

public static VarName createFreshVariable(Set<VarName> vars,
                                          VarName var)

generate a fresh variable avoiding global variables and variables from the same query

Parameters:

vars - vars to be avoided

var - variable to be generated a fresh replacement

Returns:

fresh variables

createTransitiveRule

public static Rule createTransitiveRule(RelationType relType,
                                        TypeName fromRoleName,
                                        TypeName toRoleName,
                                        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

fromRoleName - from directional role type type name

toRoleName - to directional role type type name

graph - graph for the rule to be inserted

Returns:

rule instance

createReflexiveRule

public static Rule createReflexiveRule(RelationType relType,
                                       GraknGraph graph)

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

Parameters:

relType - reflexive relation type

graph - graph for the rule to be inserted

Returns:

rule instance

createSubPropertyRule

public static Rule createSubPropertyRule(RelationType parent,
                                         RelationType child,
                                         Map<TypeName,TypeName> 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,
                                           TypeName fromRoleName,
                                           TypeName toRoleName,
                                           LinkedHashMap<RelationType,javafx.util.Pair<TypeName,TypeName>> chain,
                                           GraknGraph graph)

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

Parameters:

relation - head relation

fromRoleName - specifies the role directionality of the head relation

toRoleName - 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

getNonMetaTopRole

public static RoleType getNonMetaTopRole(RoleType role)

Parameters:

role - in question

Returns:

top non-meta super role of the role

checkTypesCompatible

public static boolean checkTypesCompatible(Type parent,
                                           Type child)

Parameters:

parent - type

child - type

Returns:

true if child is subtype of parent