Package org.opennars.inference

Class RuleTables

java.lang.Object

org.opennars.inference.RuleTables

public class RuleTables
extends Object

Table of inference rules, indexed by the TermLinks for the task and the belief. Used in indirective processing of a task, to dispatch inference cases to the relevant inference rules.

Author:

Pei Wang, Patrick Hammer

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static class	RuleTables.EnumFigureSide

Constructor Summary

Constructors

Constructor	Description
RuleTables()

Method Summary

Modifier and Type	Method	Description
private static void	applyRuleTable(TaskLink tLink, TermLink bLink, DerivationContext nal, Task task, Sentence taskSentence, Term taskTerm, Term beliefTerm, Sentence belief)
private static void	asymmetricAsymmetric(Sentence taskSentence, Sentence belief, int figure, DerivationContext nal)	Syllogistic rules whose both premises are on the same asymmetric relation
private static void	asymmetricSymmetric(Sentence asym, Sentence sym, int figure, DerivationContext nal)	Syllogistic rules whose first premise is on an asymmetric relation, and the second on a symmetric relation
private static void	componentAndStatement(CompoundTerm compound, short index, Statement statement, short side, DerivationContext nal)	Inference between a component term (of the current term) and a statement
private static void	compoundAndCompound(CompoundTerm taskTerm, CompoundTerm beliefTerm, int tindex, int bindex, DerivationContext nal)	Inference between two compound terms
private static void	compoundAndSelf(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	Inference between a compound term and a component of it
private static void	compoundAndStatement(CompoundTerm compound, short index, Statement statement, short side, Term beliefTerm, DerivationContext nal)	Inference between a compound term and a statement
private static void	conditionalDedIndWithVar(Sentence conditionalSentence, Implication conditional, short index, Statement statement, short side, DerivationContext nal)	Conditional deduction or induction, with variable unification
private static void	detachmentWithVar(Sentence originalMainSentence, Sentence subSentence, int index, boolean checkTermAgain, DerivationContext nal)
private static void	detachmentWithVar(Sentence originalMainSentence, Sentence subSentence, int index, DerivationContext nal)	The detachment rule, with variable unification
private static void	goalFromQuestion(Task task, Term taskTerm, DerivationContext nal)
static void	goalFromWantBelief(Task task, short tIndex, short bIndex, Term taskTerm, DerivationContext nal, Term beliefTerm)
private static int	indexToFigure(TLink link1, TLink link2)	Decide the figure of syllogism according to the locations of the common term in the premises
static void	reason(TaskLink tLink, TermLink bLink, DerivationContext nal)	Entry point of the inference engine
private static Statement.EnumStatementSide	retSideFromFigure(int figure, RuleTables.EnumFigureSide sideOfFigure)	converts the side of a figure to a zero based index - which determines the side of the Statement a figure is a encoding for the sides
private static void	syllogisms(TaskLink tLink, TermLink bLink, Term taskTerm, Term beliefTerm, DerivationContext nal)	Meta-table of syllogistic rules, indexed by the content classes of the taskSentence and the belief
private static void	symmetricSymmetric(Sentence belief, Sentence taskSentence, int figure, DerivationContext nal)	Syllogistic rules whose both premises are on the same symmetric relation
static void	transformTask(TaskLink tLink, DerivationContext nal)	The TaskLink is of type TRANSFORM, and the conclusion is an equivalent transformation

Methods inherited from class java.lang.Object

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

Constructor Detail

RuleTables

public RuleTables()

Method Detail

reason

public static void reason(TaskLink tLink,
                          TermLink bLink,
                          DerivationContext nal)

Entry point of the inference engine

Parameters:

tLink - The selected TaskLink, which will provide a task

bLink - The selected TermLink, which may provide a belief

applyRuleTable

private static void applyRuleTable(TaskLink tLink,
                                   TermLink bLink,
                                   DerivationContext nal,
                                   Task task,
                                   Sentence taskSentence,
                                   Term taskTerm,
                                   Term beliefTerm,
                                   Sentence belief)

goalFromWantBelief

public static void goalFromWantBelief(Task task,
                                      short tIndex,
                                      short bIndex,
                                      Term taskTerm,
                                      DerivationContext nal,
                                      Term beliefTerm)

goalFromQuestion

private static void goalFromQuestion(Task task,
                                     Term taskTerm,
                                     DerivationContext nal)

syllogisms

private static void syllogisms(TaskLink tLink,
                               TermLink bLink,
                               Term taskTerm,
                               Term beliefTerm,
                               DerivationContext nal)

Meta-table of syllogistic rules, indexed by the content classes of the taskSentence and the belief

Parameters:

tLink - The link to task

bLink - The link to belief

taskTerm - The content of task

beliefTerm - The content of belief

nal - Reference to the memory

indexToFigure

private static final int indexToFigure(TLink link1,
                                       TLink link2)

Decide the figure of syllogism according to the locations of the common term in the premises

Parameters:

link1 - The link to the first premise

link2 - The link to the second premise

Returns:

The figure of the syllogism, one of the four: 11, 12, 21, or 22

asymmetricAsymmetric

private static void asymmetricAsymmetric(Sentence taskSentence,
                                         Sentence belief,
                                         int figure,
                                         DerivationContext nal)

Syllogistic rules whose both premises are on the same asymmetric relation

Parameters:

taskSentence - The taskSentence in the task

belief - The judgment in the belief

figure - The location of the shared term

nal - Reference to the memory

asymmetricSymmetric

private static void asymmetricSymmetric(Sentence asym,
                                        Sentence sym,
                                        int figure,
                                        DerivationContext nal)

Syllogistic rules whose first premise is on an asymmetric relation, and the second on a symmetric relation

Parameters:

asym - The asymmetric premise

sym - The symmetric premise

figure - The location of the shared term

nal - Reference to the memory

retSideFromFigure

private static Statement.EnumStatementSide retSideFromFigure(int figure,
                                                             RuleTables.EnumFigureSide sideOfFigure)

converts the side of a figure to a zero based index - which determines the side of the Statement a figure is a encoding for the sides

Parameters:

figure - figure encoding as 11 or 12 or 21 or 22

sideOfFigure - side

Returns:

symmetricSymmetric

private static void symmetricSymmetric(Sentence belief,
                                       Sentence taskSentence,
                                       int figure,
                                       DerivationContext nal)

Syllogistic rules whose both premises are on the same symmetric relation

Parameters:

belief - The premise that comes from a belief

taskSentence - The premise that comes from a task

figure - The location of the shared term

nal - Reference to the memory

detachmentWithVar

private static void detachmentWithVar(Sentence originalMainSentence,
                                      Sentence subSentence,
                                      int index,
                                      DerivationContext nal)

The detachment rule, with variable unification

Parameters:

originalMainSentence - The premise that is an Implication or Equivalence

subSentence - The premise that is the subject or predicate of the first one

index - The location of the second premise in the first

nal - Reference to the memory

detachmentWithVar

private static void detachmentWithVar(Sentence originalMainSentence,
                                      Sentence subSentence,
                                      int index,
                                      boolean checkTermAgain,
                                      DerivationContext nal)

conditionalDedIndWithVar

private static void conditionalDedIndWithVar(Sentence conditionalSentence,
                                             Implication conditional,
                                             short index,
                                             Statement statement,
                                             short side,
                                             DerivationContext nal)

Conditional deduction or induction, with variable unification

Parameters:

conditional - The premise that is an Implication with a Conjunction as condition

index - The location of the shared term in the condition

statement - The second premise that is a statement

side - The location of the shared term in the statement

nal - Reference to the memory

compoundAndSelf

private static void compoundAndSelf(CompoundTerm compound,
                                    Term component,
                                    boolean compoundTask,
                                    int index,
                                    DerivationContext nal)

Inference between a compound term and a component of it

Parameters:

compound - The compound term

component - The component term

compoundTask - Whether the compound comes from the task

nal - Reference to the memory

compoundAndCompound

private static void compoundAndCompound(CompoundTerm taskTerm,
                                        CompoundTerm beliefTerm,
                                        int tindex,
                                        int bindex,
                                        DerivationContext nal)

Inference between two compound terms

Parameters:

taskTerm - The compound from the task

beliefTerm - The compound from the belief

nal - Reference to the memory

compoundAndStatement

private static void compoundAndStatement(CompoundTerm compound,
                                         short index,
                                         Statement statement,
                                         short side,
                                         Term beliefTerm,
                                         DerivationContext nal)

Inference between a compound term and a statement

Parameters:

compound - The compound term

index - The location of the current term in the compound

statement - The statement

side - The location of the current term in the statement

beliefTerm - The content of the belief

nal - Reference to the memory

componentAndStatement

private static void componentAndStatement(CompoundTerm compound,
                                          short index,
                                          Statement statement,
                                          short side,
                                          DerivationContext nal)

Inference between a component term (of the current term) and a statement

Parameters:

compound - The compound term

index - The location of the current term in the compound

statement - The statement

side - The location of the current term in the statement

nal - Reference to the memory

transformTask

public static void transformTask(TaskLink tLink,
                                 DerivationContext nal)

The TaskLink is of type TRANSFORM, and the conclusion is an equivalent transformation

Parameters:

tLink - The task link

nal - Reference to the memory