Package org.opennars.inference

Class StructuralRules

java.lang.Object

org.opennars.inference.StructuralRules

public final class StructuralRules
extends Object

Single-premise inference rules involving compound terms. Input are one sentence (the premise) and one TermLink (indicating a component)

Author:

Pei Wang, Patrick Hammer

Constructor Summary

Constructors

Constructor	Description
StructuralRules()

Method Summary

Modifier and Type	Method	Description
protected static boolean	contraposition(Statement statement, Sentence sentence, DerivationContext nal)	{<A ==> B>, A@(--, A)} |- <(--, B) ==> (--, A)>
private static void	createSequenceTaskByRange(Conjunction sourceConjunction, int inclusiveStartIndex, int inclusiveEndIndex, DerivationContext nal)	Derives a sub-sequence of a sequence based on a (inclusive) index range
private static void	deriveSequenceTask(DerivationContext nal, Conjunction parentConj, Term[] total, TruthValue truth)	Derives a sequence task, inheriting properties from parentConj
(package private) static void	flattenSequence(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(#,(#,A,B),C), (#,A,B)@(#,(#,A,B), C)} |- (#,A,B,C) (same for &/)
(package private) static void	groupSequence(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(#,A,B,C,D,E), C@(#,A,B,C,D,E)} |- (#,(#,A,B),C,D,E), (#,A,B,C,(#,D,E)) Group sequence left and right Works for all conjunctions
static void	seqToImage(Conjunction conj, int index, DerivationContext nal)
(package private) static void	splitConjunctionApart(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(#,A,B,C,D,E), C@(#,A,B,C,D,E)} |- (#,A,B,C), (#,C,D,E) Works for all conjunctions
(package private) static void	structuralCompose1(CompoundTerm compound, short index, Statement statement, DerivationContext nal)	{<S --> P>, P@(P|Q)} |- <S --> (P|Q)>
(package private) static void	structuralCompose2(CompoundTerm compound, short index, Statement statement, short side, DerivationContext nal)	{<S --> P>, S@(S&T)} |- <(S&T) --> (P&T)> {<S --> P>, S@(M-S)} |- <(M-P) --> (M-S)>
(package private) static boolean	structuralCompound(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(&&, A, B), A@(&&, A, B)} |- A, or answer (&&, A, B)? using A {(||, A, B), A@(||, A, B)} |- A, or answer (||, A, B)? using A
(package private) static void	structuralDecompose1(CompoundTerm compound, short index, Statement statement, DerivationContext nal)	{<(S|T) --> P>, S@(S|T)} |- <S --> P> {<S --> (P&T)>, P@(P&T)} |- <S --> P>
(package private) static void	structuralDecompose2(Statement statement, int index, DerivationContext nal)	{<(S*T) --> (P*T)>, S@(S*T)} |- <S --> P>
private static void	structuralStatement(Term subject, Term predicate, int order, TruthValue truth, DerivationContext nal)	Common final operations of the above two methods
private static boolean	switchOrder(CompoundTerm compound, short index)	List the cases where the direction of inheritance is revised in conclusion
(package private) static void	takeOutFromConjunction(CompoundTerm compound, Term component, boolean compoundTask, int index, DerivationContext nal)	{(&&,A,B,C), B@(&&,A,B,C)} |- (&&,A,C) Works for all conjunctions
static void	transformNegation(CompoundTerm content, DerivationContext nal)	{A, A@(--, A)} |- (--, A)
private static void	transformPredicatePI(short index, Term subject, CompoundTerm predicate, DerivationContext nal)	Equivalent transformation between products and images when the predicate is a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)> {<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P> {<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>
(package private) static void	transformProductImage(Inheritance inh, CompoundTerm oldContent, short[] indices, DerivationContext nal)	Equivalent transformation between products and images {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)> {<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P> {<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>
(package private) static void	transformSetRelation(CompoundTerm compound, Statement statement, short side, DerivationContext nal)	{<S --> {P}>} |- <S <-> {P}>
private static void	transformSubjectPI(short index, CompoundTerm subject, Term predicate, DerivationContext nal)	Equivalent transformation between products and images when the subject is a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)> {<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P> {<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>

Methods inherited from class java.lang.Object

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

Constructor Detail

StructuralRules

public StructuralRules()

Method Detail

structuralCompose2

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

{<S --> P>, S@(S&T)} |- <(S&T) --> (P&T)>
{<S --> P>, S@(M-S)} |- <(M-P) --> (M-S)>

Parameters:

compound - The compound term

index - The location of the indicated term in the compound

statement - The premise

side - The location of the indicated term in the premise

nal - Reference to the memory

structuralDecompose2

static void structuralDecompose2(Statement statement,
                                 int index,
                                 DerivationContext nal)

{<(S*T) --> (P*T)>, S@(S*T)} |- <S --> P>

Parameters:

statement - The premise

nal - Reference to the memory

switchOrder

private static boolean switchOrder(CompoundTerm compound,
                                   short index)

List the cases where the direction of inheritance is revised in conclusion

Parameters:

compound - The compound term

index - The location of focus in the compound

Returns:

Whether the direction of inheritance should be revised

structuralCompose1

static void structuralCompose1(CompoundTerm compound,
                               short index,
                               Statement statement,
                               DerivationContext nal)

{<S --> P>, P@(P|Q)} |- <S --> (P|Q)>

Parameters:

compound - The compound term

index - The location of the indicated term in the compound

statement - The premise

nal - Reference to the memory

structuralDecompose1

static void structuralDecompose1(CompoundTerm compound,
                                 short index,
                                 Statement statement,
                                 DerivationContext nal)

{<(S|T) --> P>, S@(S|T)} |- <S --> P>
{<S --> (P&T)>, P@(P&T)} |- <S --> P>

Parameters:

compound - The compound term

index - The location of the indicated term in the compound

statement - The premise

nal - Reference to the memory

structuralStatement

private static void structuralStatement(Term subject,
                                        Term predicate,
                                        int order,
                                        TruthValue truth,
                                        DerivationContext nal)

Common final operations of the above two methods

Parameters:

subject - The subject of the new task

predicate - The predicate of the new task

truth - The truth value of the new task

nal - Reference to the memory

transformSetRelation

static void transformSetRelation(CompoundTerm compound,
                                 Statement statement,
                                 short side,
                                 DerivationContext nal)

{<S --> {P}>} |- <S <-> {P}>

Parameters:

compound - The set compound

statement - The premise

side - The location of the indicated term in the premise

nal - Reference to the memory

transformProductImage

static void transformProductImage(Inheritance inh,
                                  CompoundTerm oldContent,
                                  short[] indices,
                                  DerivationContext nal)

Equivalent transformation between products and images {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)>
{<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P>
{<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>

Parameters:

inh - An Inheritance statement

oldContent - The whole content

indices - The indices of the TaskLink

nal - Reference to the memory

transformSubjectPI

private static void transformSubjectPI(short index,
                                       CompoundTerm subject,
                                       Term predicate,
                                       DerivationContext nal)

Equivalent transformation between products and images when the subject is a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)>
{<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P>
{<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>

Parameters:

subject - The subject term

predicate - The predicate term

nal - Reference to the memory

transformPredicatePI

private static void transformPredicatePI(short index,
                                         Term subject,
                                         CompoundTerm predicate,
                                         DerivationContext nal)

Equivalent transformation between products and images when the predicate is a compound {<(*, S, M) --> P>, S@(*, S, M)} |- <S --> (/, P, _, M)>
{<S --> (/, P, _, M)>, P@(/, P, _, M)} |- <(*, S, M) --> P>
{<S --> (/, P, _, M)>, M@(/, P, _, M)} |- <M --> (/, P, S, _)>

Parameters:

subject - The subject term

predicate - The predicate term

nal - Reference to the memory

flattenSequence

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

{(#,(#,A,B),C), (#,A,B)@(#,(#,A,B), C)} |- (#,A,B,C) (same for &/)

Parameters:

compound - The premise

component - The recognized component in the premise

compoundTask - Whether the compound comes from the task

nal - Reference to the memory

takeOutFromConjunction

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

{(&&,A,B,C), B@(&&,A,B,C)} |- (&&,A,C) Works for all conjunctions

Parameters:

compound - The premise

component - The recognized component in the premise

compoundTask - Whether the compound comes from the task

nal - Reference to the memory

splitConjunctionApart

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

{(#,A,B,C,D,E), C@(#,A,B,C,D,E)} |- (#,A,B,C), (#,C,D,E) Works for all conjunctions

Parameters:

compound - The premise

component - The recognized component in the premise

compoundTask - Whether the compound comes from the task

nal - Reference to the memory

groupSequence

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

{(#,A,B,C,D,E), C@(#,A,B,C,D,E)} |- (#,(#,A,B),C,D,E), (#,A,B,C,(#,D,E)) Group sequence left and right Works for all conjunctions

Parameters:

compound - The premise

component - The recognized component in the premise

compoundTask - Whether the compound comes from the task

nal - Reference to the memory

createSequenceTaskByRange

private static void createSequenceTaskByRange(Conjunction sourceConjunction,
                                              int inclusiveStartIndex,
                                              int inclusiveEndIndex,
                                              DerivationContext nal)

Derives a sub-sequence of a sequence based on a (inclusive) index range

Parameters:

sourceConjunction - The conjunction we take out a certain part from

inclusiveStartIndex - The start index (inclusive)

inclusiveEndIndex - The end index (inclusive)

nal - The derivation context

deriveSequenceTask

private static void deriveSequenceTask(DerivationContext nal,
                                       Conjunction parentConj,
                                       Term[] total,
                                       TruthValue truth)

Derives a sequence task, inheriting properties from parentConj

Parameters:

nal - The derivation context

total - The sub-terms the conjunction should be created from

truth - The truth value of the derivation

seqToImage

public static void seqToImage(Conjunction conj,
                              int index,
                              DerivationContext nal)

structuralCompound

static boolean structuralCompound(CompoundTerm compound,
                                  Term component,
                                  boolean compoundTask,
                                  int index,
                                  DerivationContext nal)

{(&&, A, B), A@(&&, A, B)} |- A,
or answer (&&, A, B)? using A {(||, A, B), A@(||, A, B)} |- A,
or answer (||, A, B)? using A

Parameters:

compound - The premise

component - The recognized component in the premise

compoundTask - Whether the compound comes from the task

nal - Reference to the memory

transformNegation

public static void transformNegation(CompoundTerm content,
                                     DerivationContext nal)

{A, A@(--, A)} |- (--, A)

Parameters:

content - The premise

nal - Reference to the memory

contraposition

protected static boolean contraposition(Statement statement,
                                        Sentence sentence,
                                        DerivationContext nal)

{<A ==> B>, A@(--, A)} |- <(--, B) ==> (--, A)>

Parameters:

statement - The premise

nal - Reference to the memory