Package org.opennars.inference

Class TruthFunctions

java.lang.Object

org.opennars.inference.UtilityFunctions

org.opennars.inference.TruthFunctions

public final class TruthFunctions
extends UtilityFunctions

All truth-value (and desire-value) functions used in inference rules

Author:

Pei Wang, Patrick Hammer, Robert Wünsche

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	TruthFunctions.EnumType
static class	TruthFunctions.EternalizedTruthValue	Indicates the result of eternalization Implements the same functionality like TruthValue

Constructor Summary

Constructors

Constructor	Description
TruthFunctions()

Method Summary

Modifier and Type	Method	Description
static TruthValue	abduction(TruthValue v1, float reliance, Parameters narParameters)	{M, <P ==> M>} |- P
static TruthValue	abduction(TruthValue v1, TruthValue v2, Parameters narParameters)	{<S ==> M>, <P ==> M>} |- <S ==> P>
static TruthValue	analogy(TruthValue v1, TruthValue v2, Parameters narParameters)	{<S ==> M>, <M <=> P>} |- <S ==> P>
static TruthValue	anonymousAnalogy(TruthValue v1, TruthValue v2, Parameters narParameters)	{(&&, <#x() ==> M>, <#x() ==> P>), S ==> M} |- <S ==> P>
static TruthValue	comparison(TruthValue v1, TruthValue v2, Parameters narParameters)	{<M ==> S>, <M ==> P>} |- <S <=> P>
static TruthValue	contraposition(TruthValue v1, Parameters narParameters)	{<A ==> B>} |- <(--, B) ==> (--, A)>
static TruthValue	conversion(TruthValue v1, Parameters narParameters)	{<A ==> B>} |- <B ==> A>
static TruthValue	deduction(TruthValue v1, float reliance, Parameters narParameters)	{M, <M ==> P>} |- P
static TruthValue	deduction(TruthValue v1, TruthValue v2, Parameters narParameters)	{<S ==> M>, <M ==> P>} |- <S ==> P>
static TruthValue	desireDed(TruthValue v1, TruthValue v2, Parameters narParameters)	A function specially designed for desire value [To be refined]
static TruthValue	desireInd(TruthValue v1, TruthValue v2, Parameters narParameters)	A function specially designed for desire value [To be refined]
static TruthValue	desireStrong(TruthValue v1, TruthValue v2, Parameters narParameters)	A function specially designed for desire value [To be refined]
static TruthValue	desireWeak(TruthValue v1, TruthValue v2, Parameters narParameters)	A function specially designed for desire value [To be refined]
static TruthFunctions.EternalizedTruthValue	eternalize(TruthValue v1, Parameters narParameters)	From one moment to eternal
static TruthValue	exemplification(TruthValue v1, TruthValue v2, Parameters narParameters)	{<M ==> S>, <P ==> M>} |- <S ==> P>
static TruthValue	induction(TruthValue v1, TruthValue v2, Parameters narParameters)	{<M ==> S>, <M ==> P>} |- <S ==> P>
static TruthValue	intersection(TruthValue v1, TruthValue v2, Parameters narParameters)	{<M --> S>, <M <-> P>} |- <M --> (S&P)>
static TruthValue	lookupTruthFunctionAndCompute(TruthFunctions.EnumType type, TruthValue a, TruthValue b, Parameters narParameters)	lookup the truth function and compute the value
static TruthValue	lookupTruthFunctionByBoolAndCompute(boolean flag, TruthFunctions.EnumType typeTrue, TruthFunctions.EnumType typeFalse, TruthValue a, TruthValue b, Parameters narParameters)	lookup the truth function and compute the value - for two truth functions which are decided by flag
static TruthValue	lookupTruthOrNull(TruthValue a, TruthValue b, Parameters narParameters, Object... values)	lookup the truth function by the first boolean which is true or return null if no boolean is true
static TruthValue	negation(TruthValue v1, Parameters narParameters)	{A} |- (--A)
static TruthValue	reduceConjunction(TruthValue v1, TruthValue v2, Parameters narParameters)	{(--, (&&, A, B)), B} |- (--, A)
static TruthValue	reduceConjunctionNeg(TruthValue v1, TruthValue v2, Parameters narParameters)	{(--, (&&, A, (--, B))), (--, B)} |- (--, A)
static TruthValue	reduceDisjunction(TruthValue v1, TruthValue v2, Parameters narParameters)	{(||, A, B), (--, B)} |- A
static TruthValue	resemblance(TruthValue v1, TruthValue v2, Parameters narParameters)	{<S <=> M>, <M <=> P>} |- <S <=> P>
private static TruthValue	revision(TruthValue v1, TruthValue v2, TruthValue result, Parameters narParameters)
static TruthValue	revision(TruthValue v1, TruthValue v2, Parameters narParameters)	{<S ==> P>, <S ==> P>} |- <S ==> P>
static float	temporalProjection(long sourceTime, long targetTime, long currentTime, Parameters param)
static TruthValue	union(TruthValue v1, TruthValue v2, Parameters narParameters)	{<M --> S>, <M > P>} |- <M --> (S|P)>

Methods inherited from class java.lang.Object

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

Methods inherited from class org.opennars.inference.UtilityFunctions

and, aveAri, aveGeo, c2w, or, w2c

Constructor Detail

TruthFunctions

public TruthFunctions()

Method Detail

lookupTruthFunctionAndCompute

public static TruthValue lookupTruthFunctionAndCompute(TruthFunctions.EnumType type,
                                                       TruthValue a,
                                                       TruthValue b,
                                                       Parameters narParameters)

lookup the truth function and compute the value

Parameters:

type - truth-function

a - truth value of the first premise

b - truth value of the second premise

Returns:

truth value as computed by the truth-function

lookupTruthFunctionByBoolAndCompute

public static TruthValue lookupTruthFunctionByBoolAndCompute(boolean flag,
                                                             TruthFunctions.EnumType typeTrue,
                                                             TruthFunctions.EnumType typeFalse,
                                                             TruthValue a,
                                                             TruthValue b,
                                                             Parameters narParameters)

lookup the truth function and compute the value - for two truth functions which are decided by flag

Parameters:

flag - which type to choose

typeTrue - truth-function for the case when the flag is true

typeFalse - truth-function for the case when the flag is false

a - truth value of the first premise

b - truth value of the second premise

Returns:

truth value as computed by the truth-function

lookupTruthOrNull

public static TruthValue lookupTruthOrNull(TruthValue a,
                                           TruthValue b,
                                           Parameters narParameters,
                                           Object... values)

lookup the truth function by the first boolean which is true or return null if no boolean is true

Parameters:

values - tuples of boolean conditional values and their corresponding truth function

a - truth value of the first premise

b - truth value of the second premise

Returns:

truth value as computed by the truth-function or null if no boolean value was true

conversion

public static final TruthValue conversion(TruthValue v1,
                                          Parameters narParameters)

{<A ==> B>} |- <B ==> A>

Parameters:

v1 - Truth value of the premise

Returns:

Truth value of the conclusion

negation

public static final TruthValue negation(TruthValue v1,
                                        Parameters narParameters)

{A} |- (--A)

Parameters:

v1 - Truth value of the premise

Returns:

Truth value of the conclusion

contraposition

public static final TruthValue contraposition(TruthValue v1,
                                              Parameters narParameters)

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

Parameters:

v1 - Truth value of the premise

Returns:

Truth value of the conclusion

revision

public static final TruthValue revision(TruthValue v1,
                                        TruthValue v2,
                                        Parameters narParameters)

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

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

revision

private static final TruthValue revision(TruthValue v1,
                                         TruthValue v2,
                                         TruthValue result,
                                         Parameters narParameters)

deduction

public static final TruthValue deduction(TruthValue v1,
                                         TruthValue v2,
                                         Parameters narParameters)

{<S ==> M>, <M ==> P>} |- <S ==> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

deduction

public static final TruthValue deduction(TruthValue v1,
                                         float reliance,
                                         Parameters narParameters)

{M, <M ==> P>} |- P

Parameters:

v1 - Truth value of the first premise

reliance - Confidence of the second (analytical) premise

Returns:

Truth value of the conclusion

analogy

public static final TruthValue analogy(TruthValue v1,
                                       TruthValue v2,
                                       Parameters narParameters)

{<S ==> M>, <M <=> P>} |- <S ==> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

resemblance

public static final TruthValue resemblance(TruthValue v1,
                                           TruthValue v2,
                                           Parameters narParameters)

{<S <=> M>, <M <=> P>} |- <S <=> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

abduction

public static final TruthValue abduction(TruthValue v1,
                                         TruthValue v2,
                                         Parameters narParameters)

{<S ==> M>, <P ==> M>} |- <S ==> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

abduction

public static final TruthValue abduction(TruthValue v1,
                                         float reliance,
                                         Parameters narParameters)

{M, <P ==> M>} |- P

Parameters:

v1 - Truth value of the first premise

reliance - Confidence of the second (analytical) premise

Returns:

Truth value of the conclusion

induction

public static final TruthValue induction(TruthValue v1,
                                         TruthValue v2,
                                         Parameters narParameters)

{<M ==> S>, <M ==> P>} |- <S ==> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

exemplification

public static final TruthValue exemplification(TruthValue v1,
                                               TruthValue v2,
                                               Parameters narParameters)

{<M ==> S>, <P ==> M>} |- <S ==> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

comparison

public static final TruthValue comparison(TruthValue v1,
                                          TruthValue v2,
                                          Parameters narParameters)

{<M ==> S>, <M ==> P>} |- <S <=> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

desireStrong

public static final TruthValue desireStrong(TruthValue v1,
                                            TruthValue v2,
                                            Parameters narParameters)

A function specially designed for desire value [To be refined]

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

desireWeak

public static final TruthValue desireWeak(TruthValue v1,
                                          TruthValue v2,
                                          Parameters narParameters)

A function specially designed for desire value [To be refined]

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

desireDed

public static final TruthValue desireDed(TruthValue v1,
                                         TruthValue v2,
                                         Parameters narParameters)

A function specially designed for desire value [To be refined]

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

desireInd

public static final TruthValue desireInd(TruthValue v1,
                                         TruthValue v2,
                                         Parameters narParameters)

A function specially designed for desire value [To be refined]

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

union

public static final TruthValue union(TruthValue v1,
                                     TruthValue v2,
                                     Parameters narParameters)

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

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

intersection

public static final TruthValue intersection(TruthValue v1,
                                            TruthValue v2,
                                            Parameters narParameters)

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

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

reduceDisjunction

public static final TruthValue reduceDisjunction(TruthValue v1,
                                                 TruthValue v2,
                                                 Parameters narParameters)

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

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

reduceConjunction

public static final TruthValue reduceConjunction(TruthValue v1,
                                                 TruthValue v2,
                                                 Parameters narParameters)

{(--, (&&, A, B)), B} |- (--, A)

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

reduceConjunctionNeg

public static final TruthValue reduceConjunctionNeg(TruthValue v1,
                                                    TruthValue v2,
                                                    Parameters narParameters)

{(--, (&&, A, (--, B))), (--, B)} |- (--, A)

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

anonymousAnalogy

public static final TruthValue anonymousAnalogy(TruthValue v1,
                                                TruthValue v2,
                                                Parameters narParameters)

{(&&, <#x() ==> M>, <#x() ==> P>), S ==> M} |- <S ==> P>

Parameters:

v1 - Truth value of the first premise

v2 - Truth value of the second premise

Returns:

Truth value of the conclusion

eternalize

public static final TruthFunctions.EternalizedTruthValue eternalize(TruthValue v1,
                                                                    Parameters narParameters)

From one moment to eternal

Parameters:

v1 - Truth value of the premise

Returns:

Truth value of the conclusion

temporalProjection

public static final float temporalProjection(long sourceTime,
                                             long targetTime,
                                             long currentTime,
                                             Parameters param)