Fuzzy Logic Ontology

FLOW_ALGEBRA FuzzyLogicDetailedOntology v1.0

TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/fuzzy-logic/fuzzy-logic-ontology.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > FuzzyLogic > FuzzyLogicOntology

BEGIN_FLOW

ENTITY FuzzyLogic {
    TYPE := ManyValuedLogicalFramework
    TRUTH_DOMAIN := [0,1]
    DEFINITION := "A formal system for representing and reasoning with graded truth, vague predicates and fuzzy set membership rather than restricting evaluation to binary false and true."
}

ENTITY FuzzyTruthDegree {
    TYPE := RealValue
    DOMAIN := [0,1]
}

ENTITY FuzzySet {
    TYPE := GeneralisedSet
    UNIVERSE := X
    MEMBERSHIP := μ_A:X->[0,1]
}

ENTITY MembershipFunction {
    TYPE := Function
    MAPS := UniverseElement -> MembershipDegree
}

RELATIONSHIP FuzzyLogic --uses--> FuzzyTruthDegree
RELATIONSHIP FuzzyLogic --uses--> FuzzySet
RELATIONSHIP FuzzySet --defined_by--> MembershipFunction
RELATIONSHIP FuzzyLogic --supports--> LinguisticReasoning
RELATIONSHIP FuzzyLogic --supports--> ApproximateReasoning

CRISP_BOUNDARY {
    FALSE := 0
    TRUE := 1
    IF all_values ∈ {0,1}
    THEN selected fuzzy semantics may reduce to corresponding crisp Boolean behaviour
}

FUZZY_PROPOSITION {
    FORM := "x is A"
    TRUTH_DEGREE := μ_A(x)
}

MEMBERSHIP_SEMANTICS {
    μ_A(x)=0 := no_membership
    μ_A(x)=1 := full_membership
    0<μ_A(x)<1 := partial_membership
}

SEMANTIC_WARNING {
    MembershipDegree != Probability
    FuzzyTruthDegree != StatisticalConfidence
    FuzzyTruthDegree != Frequency
}

ENTITY TNorm {
    TYPE := FuzzyConjunction
    SIGNATURE := [0,1]^2 -> [0,1]
    AXIOMS := {Commutativity,Associativity,Monotonicity,Boundary_T(x,1)=x}
}

ENTITY TConorm {
    TYPE := FuzzyDisjunction
    SIGNATURE := [0,1]^2 -> [0,1]
    AXIOMS := {Commutativity,Associativity,Monotonicity,Boundary_S(x,0)=x}
}

STANDARD_NEGATION { N(x) := 1-x }
MINIMUM_TNORM { T_M(x,y) := min(x,y) }
PRODUCT_TNORM { T_P(x,y) := x*y }
LUKASIEWICZ_TNORM { T_L(x,y) := max(0,x+y-1) }
MAXIMUM_TCONORM { S_M(x,y) := max(x,y) }
PROBABILISTIC_SUM { S_P(x,y) := x+y-x*y }
LUKASIEWICZ_TCONORM { S_L(x,y) := min(1,x+y) }

FUZZY_INTERSECTION {
    μ_(A∩B)(x) := T(μ_A(x),μ_B(x))
}

FUZZY_UNION {
    μ_(A∪B)(x) := S(μ_A(x),μ_B(x))
}

FUZZY_COMPLEMENT {
    μ_(¬A)(x) := N(μ_A(x))
}

ALPHA_CUT {
    A_alpha := {x | μ_A(x)>=alpha}
}

STRONG_ALPHA_CUT {
    A_alpha_plus := {x | μ_A(x)>alpha}
}

SUPPORT { support(A) := {x | μ_A(x)>0} }
CORE { core(A) := {x | μ_A(x)=1} }
HEIGHT { height(A) := sup_x μ_A(x) }

NORMALITY {
    A IS normal IFF height(A)=1
}

FUZZY_CONVEXITY {
    A IS fuzzy_convex IFF
        μ_A(λx+(1-λ)y) >= min(μ_A(x),μ_A(y))
        FOR_ALL λ∈[0,1]
}


LINGUISTIC_VARIABLE {
    COMPONENTS := {Name,UniverseOfDiscourse,LinguisticTerms,MembershipFunctions}
}

LINGUISTIC_TERM {
    TYPE := LabelledFuzzySet
}

MEMBERSHIP_FUNCTION_TYPES {
    TYPES := {Triangular,Trapezoidal,Gaussian,Bell,Sigmoidal,Singleton}
}

TRIANGULAR_MF(x,a,b,c) {
    IF x<=a OR x>=c RETURN 0
    IF a<x<=b RETURN (x-a)/(b-a)
    IF b<x<c RETURN (c-x)/(c-b)
}

TRAPEZOIDAL_MF(x,a,b,c,d) {
    IF x<=a OR x>=d RETURN 0
    IF a<x<b RETURN (x-a)/(b-a)
    IF b<=x<=c RETURN 1
    IF c<x<d RETURN (d-x)/(d-c)
}

GAUSSIAN_MF(x,c,sigma) {
    REQUIRE sigma>0
    RETURN exp(-((x-c)^2)/(2*sigma^2))
}

FUZZY_RULE {
    FORM := IF Antecedent THEN Consequent
}

FUZZY_RULE_BASE {
    TYPE := SetOfFuzzyRules
}

FUZZY_INFERENCE_SYSTEM {
    COMPONENTS := {
        InputVariables,
        MembershipFunctions,
        RuleBase,
        InferenceEngine,
        AggregationMethod,
        OutputMethod
    }
}

FUZZIFICATION(InputVector X) {
    FOR_EACH input_variable xi
    FOR_EACH fuzzy_term Aij:
        degree_ij := μ_Aij(xi)
    RETURN all_input_membership_degrees
}

ANTECEDENT_EVALUATION(Antecedent A) {
    PARSE A
    IF conjunction APPLY selected_t_norm
    IF disjunction APPLY selected_t_conorm
    IF negation APPLY selected_negation
    RETURN firing_strength
}

MAMDANI_INFERENCE {
    RULE := IF x IS A THEN y IS B
    firing_strength := antecedent_degree
    ACTIVATE consequent_using_declared_implication
    AGGREGATE all_rule_outputs
    DEFUZZIFY if crisp_output_required
}

SUGENO_INFERENCE {
    RULE := IF antecedent THEN z=f(inputs)
    OUTPUT :=
        SUM_i(w_i*z_i) / SUM_i(w_i)
    REQUIRE SUM_i(w_i)!=0
}

CENTROID_DEFUZZIFICATION {
    y_star :=
        integral(y*μ(y)dy) /
        integral(μ(y)dy)
    REQUIRE denominator!=0
}

BISECTOR_DEFUZZIFICATION {
    FIND y_star WHERE
        area_left(y_star)=area_right(y_star)
}

MEAN_OF_MAXIMA {
    OUTPUT := mean(points_at_maximum_membership)
}

ENTITY FuzzyImplication {
    TYPE := BinaryFuzzyOperator
    SIGNATURE := [0,1]^2->[0,1]
}

LUKASIEWICZ_IMPLICATION {
    I_L(a,b) := min(1,1-a+b)
}

GODEL_IMPLICATION {
    I_G(a,b) := IF a<=b THEN 1 ELSE b
}

REICHENBACH_IMPLICATION {
    I_R(a,b) := 1-a+a*b
}

RESIDUATED_IMPLICATION {
    GIVEN t_norm T
    I_T(a,b) := sup{c∈[0,1] | T(a,c)<=b}
}

FUZZY_RELATION {
    TYPE := FuzzySetOverCartesianProduct
    MEMBERSHIP := μ_R(x,y)
}

MAX_MIN_COMPOSITION {
    μ_(R∘S)(x,z) :=
        sup_y min(μ_R(x,y),μ_S(y,z))
}

MAX_PRODUCT_COMPOSITION {
    μ_(R∘S)(x,z) :=
        sup_y (μ_R(x,y)*μ_S(y,z))
}

FUZZY_NUMBER {
    TYPE := FuzzySetOverNumericDomain
    COMMON_PROPERTIES := {Normality,Convexity,BoundedSupport}
}

EXTENSION_PRINCIPLE {
    GIVEN f:X->Y
    μ_B(y) :=
        sup{μ_A(x) | f(x)=y}
}

FUZZY_ARITHMETIC {
    INPUT := FuzzyNumbers
    METHOD := ExtensionPrinciple OR AlphaCutArithmetic
}


TYPE_1_FUZZY_SET {
    μ_A(x) ∈ [0,1]
}

TYPE_2_FUZZY_SET {
    SECONDARY_MEMBERSHIP := μ_A(x,u) ∈ [0,1]
}

INTERVAL_TYPE_2_FUZZY_SET {
    SECONDARY_MEMBERSHIP :=
        1 across interval-valued footprint_of_uncertainty
}

FOOTPRINT_OF_UNCERTAINTY {
    ABBREVIATION := FOU
    TYPE := RegionOfPossiblePrimaryMembershipValues
}

TYPE_REDUCTION {
    INPUT := Type2FuzzyOutput
    OUTPUT := Type1FuzzySetOrInterval
    PRECEDES := Defuzzification
}

FUZZY_LOGIC_VS_BOOLEAN {
    BooleanTruthDomain := {0,1}
    FuzzyTruthDomain := [0,1]
    BooleanLogic --is_boundary_case_of--> selected_fuzzy_semantics
}

FUZZY_LOGIC_VS_PROBABILITY {
    FuzzyDegree := degree_of_truth_or_membership
    Probability := uncertainty_measure_over_events
    MUST_REMAIN_SEMANTICALLY_DISTINCT := TRUE
}

APPROXIMATE_REASONING {
    FuzzyFacts + FuzzyRules
        -> GradedInference
        -> FuzzyConclusion
}

FUZZY_CONTROL {
    SensorValues
        -> Fuzzification
        -> RuleEvaluation
        -> Aggregation
        -> Defuzzification
        -> ControlAction
}

APPLICATION_RELATIONSHIPS {
    FuzzyLogic --supports--> ControlEngineering
    FuzzyLogic --supports--> ExpertSystems
    FuzzyLogic --supports--> DecisionSupport
    FuzzyLogic --supports--> PatternRecognition
    FuzzyLogic --supports--> Classification
    FuzzyLogic --supports--> Robotics
    FuzzyLogic --supports--> ArtificialIntelligence
    FuzzyLogic --supports--> ImageProcessing
    FuzzyLogic --supports--> DataFusion
    FuzzyLogic --supports--> ApproximateReasoning
}

ONTOLOGY_LINKS {
    PARENT := FuzzyLogicOntology
    RELATED := {
        BooleanLogicOntology,
        ManyValuedLogicOntology,
        FuzzySetOntology,
        MembershipFunctionOntology,
        TNormOntology,
        TConormOntology,
        FuzzyRelationOntology,
        FuzzyNumberOntology,
        ApproximateReasoningOntology,
        ProbabilityOntology,
        DecisionTheoryOntology
    }
}

SEMANTIC_EQUIVALENCE {
    FuzzyTruthDegree ≈ DegreeOfTruth
    MembershipDegree ≈ FuzzyMembershipValue
    FuzzyConjunction ≈ TNorm
        WHEN conjunction_is_defined_by_selected_t_norm
    FuzzyDisjunction ≈ TConorm
        WHEN disjunction_is_defined_by_selected_t_conorm
    StandardNegation(x) ≈ 1-x
        WHEN standard_fuzzy_negation_selected
}

CONSTRAINTS {
    C1 := all fuzzy truth and membership values MUST remain within declared domain
    C2 := fuzzy membership MUST NOT be interpreted as probability by default
    C3 := fuzzy truth MUST NOT be interpreted as statistical confidence by default
    C4 := operator families MUST be explicitly selected where numerical results depend on them
    C5 := Mamdani and Sugeno inference semantics MUST remain distinct
    C6 := defuzzification method MUST be identified before deriving a crisp output
    C7 := Type-1 and Type-2 fuzzy representations MUST remain distinct
    C8 := fuzzy relation composition MUST declare its aggregation operators
    C9 := linguistic variables MUST be grounded in explicit fuzzy sets
    C10 := crisp Boolean identities MUST NOT transfer to arbitrary fuzzy operators unless valid
    C11 := fuzzy arithmetic MUST preserve selected extension semantics
    C12 := transformations MUST preserve numerical and conceptual meaning
}

REASONING_CHAIN Query Q {
    IDENTIFY fuzzy_logic_variant
    IDENTIFY truth_domain
    IDENTIFY universe_of_discourse
    IDENTIFY variables
    IDENTIFY fuzzy_sets
    IDENTIFY membership_functions
    IDENTIFY operator_family

    IF crisp_inputs
        THEN FUZZIFICATION

    IF fuzzy_expression {
        PARSE expression
        APPLY selected_t_norm
        APPLY selected_t_conorm
        APPLY selected_negation
        APPLY selected_implication
    }

    IF fuzzy_rules {
        COMPUTE firing_strengths
        COMPUTE consequents
        AGGREGATE rule_outputs
    }

    IF Mamdani_context
        THEN apply Mamdani_inference

    IF Sugeno_context
        THEN apply weighted_functional_output

    IF crisp_output_requested
        THEN apply declared_defuzzification

    IF alpha_cut_requested
        THEN derive alpha_cut

    IF fuzzy_relation_requested
        THEN apply declared_composition

    IF Type2_context {
        IDENTIFY footprint_of_uncertainty
        APPLY type_reduction_before_defuzzification
    }

    IF probability_comparison
        THEN enforce semantic_distinction

    VALIDATE domains
    VALIDATE operator_axioms
    VALIDATE inference_consistency
    RETURN result WITH derivation
}

CONFIDENCE {
    CORE_FUZZY_LOGIC_DEFINITION := 1.00
    FUZZY_SET_MEMBERSHIP := 1.00
    TNORM_TCONORM_AXIOMS := 1.00
    STANDARD_OPERATOR_EXAMPLES := 1.00
    MAMDANI_SUGENO_FRAMEWORKS := 0.99
    TYPE2_CORE_DISTINCTION := 0.99

    COMPUTED_RESULT :=
        IF all_required_functions_and_operators_given THEN 1.00
        ELSE REQUIRE missing_information
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        GradedTruth,
        FuzzyMembership,
        MembershipFunctions,
        OperatorDomainConstraints
    }

    EXTENSIBLE := {
        TNormFamilies,
        TConormFamilies,
        Negations,
        Implications,
        MembershipFunctions,
        InferenceArchitectures,
        Type2Systems,
        FuzzyRelations,
        FuzzyArithmetic,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY fuzzy_semantic_framework
        VALIDATE degree_domain
        VALIDATE membership_function
        VALIDATE operator_axioms
        VALIDATE inference_pipeline
        CHECK semantic_consistency
        ADD relationship IF non_contradictory
        UPDATE confidence
    }
}

AI_CONSUMPTION {
    MACHINE_READABLE := TRUE
    HUMAN_INTERPRETABLE := TRUE
    RECURSIVE_REASONING := TRUE
    ENTITY_RESOLUTION := TRUE
    SYMBOL_RESOLUTION := TRUE
    RELATIONSHIP_TRAVERSAL := TRUE
    GRADED_TRUTH_REASONING := TRUE
    FUZZY_SET_REASONING := TRUE
    MEMBERSHIP_EVALUATION := TRUE
    FUZZY_OPERATOR_REASONING := TRUE
    RULE_BASE_REASONING := TRUE
    DEFUZZIFICATION_REASONING := TRUE
    TYPE2_REASONING := TRUE
    FUZZY_RELATION_REASONING := TRUE
    VALIDATION_REQUIRED := TRUE
}

FLOW_HASH {
    TARGET := TARGET_URL
    SUBJECT := "Fuzzy Logic Ontology"
    VERSION := "1.0"
    CANONICAL_SIGNATURE :=
        HASH(TARGET + SUBJECT + DOMAIN + VERSION)
}

OUTPUT {
    PRIMARY_ENTITY := FuzzyLogic
    INTERPRETATION :=
        "Fuzzy logic formalises graded truth and membership, commonly over [0,1]. It combines fuzzy sets, membership functions, configurable logical operators and rule-based inference systems to represent vague concepts, derive graded conclusions and produce crisp decisions when an explicit defuzzification method is applied."
}

END_FLOW