
Orbital library  
PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 
java.lang.Object orbital.moon.logic.FuzzyLogic
public class FuzzyLogic
Implementation of quantitative fuzzy logics.
Fuzzy logic is a numeric approach in which truthvalues represent a degree of truth specified as a real number in the range [0,1]. (Unlike probabilities in the range [0,1] which specify a degree of belief.)
⋏:[0,1]^{2}→[0,1] is a fuzzy AND operator, or triangular norm, iff  
(n)  a ⋏ 1 = a  "neutral" 
(c)  a ⋏ b = b ⋏ a  "commutative" 
(mon)  a_{1}≤a_{2} and b_{1}≤b_{2} implies a_{1} ⋏ b_{1} ≤ a_{2} ⋏ b_{2}  "monotonic" 
(a)  a ⋏ (b ⋏ c) = (a ⋏ b) ⋏ c  "associative" 
(idem)  a ⋏ a = a  "idempotent" (optional) 
(C)  ⋏ is continuous  "continuous" (optional) 
()  a ⋏ 0 = 0  (⇐ (n),(c),(mon)) 
()  0 ⋏ 0 = 0 1 ⋏ 0 = 0 0 ⋏ 1 = 0 1 ⋏ 1 = 1 
"∧ boundary conditions" (⇐ (n),(c),(mon)) 
⋎:[0,1]^{2}→[0,1] is a fuzzy OR operator or cotnorm, iff  
(n)  a ⋎ 0 = a  "neutral" 
(c)  a ⋎ b = b ⋎ a  "commutative" 
(mon)  a_{1}≤a_{2} and b_{1}≤b_{2} implies a_{1} ⋎ b_{1} ≤ a_{2} ⋎ b_{2}  "monotonic" 
(a)  a ⋎ (b ⋎ c) = (a ⋎ b) ⋎ c  "associative" 
(idem)  a ⋎ a = a  "idempotent" (optional) 
(C)  ⋎ is continuous  "continuous" (optional) 
()  a ⋏ 1 = 1  (⇐ (n),(c),(mon)) 
()  0 ⋎ 0 = 0 1 ⋎ 0 = 1 0 ⋎ 1 = 1 1 ⋎ 1 = 1 
"∨ boundary conditions" (⇐ (n),(c),(mon)) 
~ is a fuzzy NOT operator, iff  
(1)  ~1 = 0 ~0 =1 
"¬ boundary conditions" 
(mon)  a<b implies ~a ≥ ~b  "monotonic" 
(inv)  ~ ~ a = a  "involutive" (optional) 
(C)  ~ is continuous  "continuous" (optional) 
Derived operators are the fuzzy implication and bisubjunction.
Gödel and drastic operator sets bound all operator sets. For any operators (⋏,⋎) it is
μ_{A∪B} = μ_{A} ⋎ μ_{B}
μ_{A∩B} = μ_{A} ⋏ μ_{B}
μ_{A∁} = ~ μ_{A}
Also note that for fuzzy sets, idem potence and distributive on the one hand, and tertium non datur on the other hand, are mutually exclusive properties for all operators.
Nested Class Summary  

static class 
FuzzyLogic.OperatorSet
Specifies the type of fuzzy logic to use. 
Field Summary  

static FuzzyLogic.OperatorSet 
BOUNDED
Bounded or Ɨukasiewicz operators in fuzzy logic. 
static FuzzyLogic.OperatorSet 
DRASTIC
Drastic operators in fuzzy logic. 
static FuzzyLogic.OperatorSet 
GOEDEL
Gödel and Zadeh operators in fuzzy logic (default). 
static FuzzyLogic.OperatorSet 
PRODUCT
Product operators in fuzzy logic. 
static java.lang.String 
usage

Constructor Summary  

FuzzyLogic()


FuzzyLogic(FuzzyLogic.OperatorSet fuzzyLogicOperators)
Create a new fuzzy logic implementation with a specific operator set. 
Method Summary  

Expression.Composite 
compose(Expression compositor,
Expression[] arguments)
Create a compound expression representation with a composition operation. 
Formula.Composite 
composeDelayed(Formula f,
Expression[] arguments,
Notation notation)
Delayed composition of a symbol with some arguments. 
Formula.Composite 
composeFixed(Symbol fsymbol,
Functor f,
Expression[] arguments)
Instant composition of functors with a fixed core interperation Usually for predicates etc. 
Interpretation 
coreInterpretation()
Get the core interpretation which is fixed for this logic. 
Signature 
coreSignature()
Get the core signature which is supported by the language of this expression syntax. 
Expression[] 
createAllExpressions(java.lang.String expressions)
Create a sequence of (compound) expressions by parsing a list of expressions. 
Expression 
createAtomic(Symbol symbol)
Create an atomic expression representation of a noncompound sign. 
Expression 
createExpression(java.lang.String expression)
Create a term representation by parsing a (compound) expression. In fact, parsing expressions is only possible with a concrete syntax. So implementations of this method are encouraged to define and parse a standard notation which can often be close to the default notation of the abstract syntax. . 
Formula 
createFixedSymbol(Symbol symbol,
java.lang.Object referent,
boolean core)
Construct (a formula view of) an atomic symbol with a fixed interpretation. 
Formula 
createSymbol(Symbol symbol)
Construct (a formula view of) an atomic symbol. 
static FuzzyLogic.OperatorSet 
HAMACHER(double gamma)
Hamacher operators in fuzzy logic. 
boolean 
infer(java.lang.String expression,
java.lang.String exprDerived)
facade for convenience. 
Inference 
inference()
Get the inference relation ~_{K} according to the implementation calculus K. 
static void 
main(java.lang.String[] arg)
toolmain 
protected static boolean 
proveAll(java.io.Reader rd,
orbital.moon.logic.ModernLogic logic,
boolean all_true)
Prove all conjectures read from a reader. 
boolean 
satisfy(Interpretation I,
Formula F)
Defines the semantic satisfaction relation ⊧. 
Signature 
scanSignature(java.lang.String expression)
Scan for the signature Σ of all syntactic symbols in an expression. 
java.lang.String 
toString()

protected void 
validateAtomic(Symbol symbol)
This method validates that a symbol obeys the syntactical conventions imposed by this logic (if any). 
static FuzzyLogic.OperatorSet 
YAGER(double p)
Yager operators in fuzzy logic. 
Methods inherited from class java.lang.Object 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait 
Methods inherited from interface orbital.logic.imp.Logic 

compose, createAtomic, createExpression 
Methods inherited from interface orbital.logic.sign.ExpressionSyntax 

scanSignature 
Field Detail 

public static final java.lang.String usage
public static FuzzyLogic.OperatorSet GOEDEL
⇒ in the absence of further knowledge, choose Gödel operators.
public static FuzzyLogic.OperatorSet PRODUCT
public static FuzzyLogic.OperatorSet BOUNDED
public static FuzzyLogic.OperatorSet DRASTIC
Constructor Detail 

public FuzzyLogic()
public FuzzyLogic(FuzzyLogic.OperatorSet fuzzyLogicOperators)
fuzzyLogicOperators
 the set of fuzzy logic operators to use.GOEDEL
,
BOUNDED
,
PRODUCT
,
DRASTIC
,
HAMACHER(double)
,
YAGER(double)
Method Detail 

public static void main(java.lang.String[] arg) throws java.lang.Exception
java.lang.Exception
public java.lang.String toString()
public boolean infer(java.lang.String expression, java.lang.String exprDerived) throws ParseException
expression
 the comma separated list of premise expressions to parse.
ParseException
public boolean satisfy(Interpretation I, Formula F)
Logic
For multivalued logics, the above definition of a semantic satisfaction relation would experience a small generalization
Unlike the implementation method Formula.apply(Object)
, this surface method
must automatically consider the core interpretation
of this logic for symbol interpretations (and possible redefinitions) as well.
satisfy
in interface Logic
I
 the interpretation within which to evaluate F.F
 the formula to check whether it is satisfied in I.
Logic.coreInterpretation()
public Inference inference()
Logic
inference
in interface Logic
public Signature coreSignature()
ExpressionSyntax
The core "signature" contains the logical signs that inherently belong to this term algebra and are not subject to interpretation. Logical signs are logical constants like true, false, and logical operators like ¬, ∧, ∨, →, ∀, ∃. The latter are also called logical junctors.
Note that some authors do not count the core "signature" as part of the proper signature Σ but would rather call it "meta"signature.
coreSignature
in interface ExpressionSyntax
Logic.coreInterpretation()
public Interpretation coreInterpretation()
Logic
This will usually contain the interpretation functors of logical operators like ¬, ∧, ∨, →, ⇔, ∀ and ∃.
coreInterpretation
in interface Logic
ExpressionSyntax.coreSignature()
public static FuzzyLogic.OperatorSet HAMACHER(double gamma)
gamma
 the parameter γ.public static FuzzyLogic.OperatorSet YAGER(double p)
GOEDEL
.
protected static final boolean proveAll(java.io.Reader rd, orbital.moon.logic.ModernLogic logic, boolean all_true) throws ParseException, java.io.IOException
<premise> (, <premise>)^{*} = <conclusion> # <comment> <EOL> <formula> == <formula> # <comment> <EOL> ...
rd
 the source for the conjectures to prove.logic
 the logic to use.all_true
 If true
this method will return whether all conjectures in rd
could be proven.
If false
this method will return whether some conjectures in rd
could be proven.
ParseException
java.io.IOException
LogicParser.readTRS(Reader,ExpressionSyntax,Function)
public Expression createAtomic(Symbol symbol)
Logic
Atomic symbols are either elemental atoms, strings or numbers. ☡ In contrast, a logical formula that is not compound of something (on the level of logical junctors) like "P(x,y)" is sometimes called atom.
createAtomic
in interface Logic
createAtomic
in interface ExpressionBuilder
symbol
 the symbol whose atomic expression representation to create.
public Expression.Composite compose(Expression compositor, Expression[] arguments) throws ParseException, TypeException
Logic
Signature.get(String,Object[])
may be useful for determining the right functor symbol
for a composition in case of an atomic
compositor.
☡ Be aware that this method does a composition (in the sense of semiotics) of signs/expressions, but not usually a composition (in the sense of mathematics) of functions. Mathematically speaking, the composition that this method performs would usually be called application instead of composition. Although composition (in the sense of mathematics) and application are correlated, they have different types at first sight
Yet together withλ
abstraction,
composition can be expressed in terms of application (as the definition above shows).
And in conjunction with the (selective) identification of type
void→σ' with σ'
application can also be expressed per composition.
compose
in interface Logic
compose
in interface ExpressionBuilder
compositor
 the expression that is used for composing the arguments.arguments
 the arguments a
passed to the combining operation.
compositor(a[0],…,a[a.length1])
ParseException
 if the composition expression is syntactically malformed.
Either due to a lexical or grammatical error (also due to wrong type of arguments).
TypeException
 if the arguments have the wrong type for
composition, i.e. compositor.getType().on(typeOf(arg)) raises a
TypeException. Note that type errors are still a kind of
syntactic errors, but should be separated from pure parse
exceptions in order to simplify distinction for exception
handlers.public Formula createSymbol(Symbol symbol)
symbol
 the symbol for which to create a formula representationExpressionBuilder.createAtomic(Symbol)
public Formula createFixedSymbol(Symbol symbol, java.lang.Object referent, boolean core)
symbol
 the symbol for which to create a formula representationreferent
 the fixed interpretation of this symbolcore
 whether symbol is in the core such that it does not belong to the proper signature.ExpressionBuilder.createAtomic(Symbol)
public Formula.Composite composeDelayed(Formula f, Expression[] arguments, Notation notation)
f
 the compositing formula.arguments
 the arguments to the composition by f.notation
 the notation for the composition (usually determined by the composing symbol).public Formula.Composite composeFixed(Symbol fsymbol, Functor f, Expression[] arguments)
f
 the compositing formula.arguments
 the arguments to the composition by f.fsymbol
 the symbol with with the fixed interpretation f.public Expression createExpression(java.lang.String expression) throws ParseException
In fact, parsing expressions is only possible with a concrete syntax. So implementations of this method are encouraged to define and parse a standard notation which can often be close to the default notation of the abstract syntax.
. Parses single formulas or sequences of formulas delimited by comma and enclosed in curly brackets. Sequences of expressions are represented by a special compound expression encapsulating the array of expressions as itscomponent
.
createExpression
in interface Logic
createExpression
in interface ExpressionSyntax
expression
 the compound expression to parse.
A string of ""
denotes the empty expression.
However note that the empty expression may not be accepted in some term algebras.
Those parsers rejecting the empty expression are then inclined to throw a ParseException,
instead.
ParseException
 when the expression is syntactically malformed.
Either due to a lexical or grammatical error.public Signature scanSignature(java.lang.String expression) throws ParseException
ExpressionSyntax
However, note that this method does not necessarily perform rich type querying. Especially for userdefined functions with an arbitrary argumenttype structure, it is generally recommended to construct the relevant signature entries explicitly.
scanSignature
in interface ExpressionSyntax
expression
 the expression that should be scanned for symbol names.
ParseException
 (optional) when the expression is syntactically malformed.
Either due to a lexical or grammatical error.
(optional behaviour for performance reasons).
Will not throw ParseExceptions if createExpression would not either.ExpressionSyntax.coreSignature()
,
"Factory Method"public Expression[] createAllExpressions(java.lang.String expressions) throws ParseException
createExpression(String)
, but restricted to lists of expressions.
For example, in the context of conjectures when given
{A&B, A&~C}an implementation could parse it as two formulas
A&B
and A&~C
.
expressions
 the comma separated list of expressions to parse.
java.lang.UnsupportedOperationException
 if no syntax notation for sequences of formulas
has been defined.
ParseException
createExpression(String)
createExpression(String)
for sequences of expressions. So you are advised to
stick to the interface method createExpression(String)
to minimize implementation
dependencies of your code.protected void validateAtomic(Symbol symbol) throws java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
 if signifier is not an identifier.

Orbital library 1.3.0: 11 Apr 2009 

PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 