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,VarAdmin> 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, String fromRoleName, String toRoleName, LinkedHashMap<RelationType,javafx.util.Pair<String,String>> 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<String,String> roleMappings, GraknGraph graph) creates rule parent :- child
static Rule	createTransitiveRule(RelationType relType, String fromRoleName, String 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 Set<RoleType>	getNonMetaSuperRoleTypes(RoleType role) For a given role returns all its non-meta super roles.
static RoleType	getNonMetaTopRole(RoleType role)
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 <T> Set<T>	subtractSets(Set<T> A, Set<T> B)
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

printAnswers

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

Provides more readable answer output.

Parameters:

answers - set of answers to be printed

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,VarAdmin> 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,
                                        String fromRoleName,
                                        String 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<String,String> 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,
                                           String fromRoleName,
                                           String toRoleName,
                                           LinkedHashMap<RelationType,javafx.util.Pair<String,String>> 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

getNonMetaSuperRoleTypes

public static Set<RoleType> getNonMetaSuperRoleTypes(RoleType role)

For a given role returns all its non-meta super roles.

Parameters:

role - in question

Returns:

set of role's non-meta super types

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

subtractSets

public static <T> Set<T> subtractSets(Set<T> A,
                                      Set<T> B)

Type Parameters:

T - set element type

Parameters:

A - set

B - set

Returns:

results of set subtraction starting with larger set