Fuzzy Logic

FLOW_ALGEBRA FuzzyLogicOntology v1.0

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

BEGIN_FLOW

ENTITY FuzzyLogic {
    TYPE := ManyValuedLogicalFramework
    DEFINITION := "A formal framework in which propositions or set memberships may take graded truth values, commonly represented on the interval [0,1], rather than being restricted to Boolean false or true."
}

ENTITY FuzzyTruthValue {
    TYPE := Degree
    DOMAIN := [0,1]
}

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

ENTITY MembershipFunction {
    TYPE := Function
    INPUT := UniverseElement
    OUTPUT := MembershipDegree
}

RELATIONSHIP FuzzyLogic --uses--> FuzzyTruthValue
RELATIONSHIP FuzzyLogic --uses--> FuzzySet
RELATIONSHIP FuzzySet --defined_by--> MembershipFunction
RELATIONSHIP FuzzyLogic --generalises--> BooleanTruthEvaluation
RELATIONSHIP FuzzyLogic --supports--> ApproximateReasoning

CRISP_SPECIAL_CASE {
    IF truth_values ⊆ {0,1}
    THEN
        fuzzy_truth_assignment_reduces_to_crisp_boolean_assignment
}

FUZZY_MEMBERSHIP {
    FOR x ∈ X:
        μ_A(x) ∈ [0,1]

    INTERPRETATION :=
        degree_to_which_x_belongs_to_fuzzy_set_A
}

IMPORTANT_DISTINCTION {
    MEMBERSHIP_DEGREE != probability

    MEMBERSHIP_DEGREE :=
        graded compatibility/membership

    PROBABILITY :=
        uncertainty measure over events under probabilistic semantics
}

FUZZY_NEGATION_STANDARD {
    N(x) := 1 - x
}

FUZZY_AND_MIN {
    T_min(x,y) := min(x,y)
}

FUZZY_OR_MAX {
    S_max(x,y) := max(x,y)
}

PRODUCT_T_NORM {
    T_product(x,y) := x*y
}

PROBABILISTIC_SUM_T_CONORM {
    S_prob(x,y) := x + y - x*y
}

LUKASIEWICZ_T_NORM {
    T_L(x,y) := max(0,x+y-1)
}

LUKASIEWICZ_T_CONORM {
    S_L(x,y) := min(1,x+y)
}

ENTITY TNorm {
    TYPE := FuzzyConjunctionOperator

    REQUIRE {
        Commutativity
        Associativity
        Monotonicity
        BoundaryCondition_T(x,1)=x
    }
}

ENTITY TConorm {
    TYPE := FuzzyDisjunctionOperator

    REQUIRE {
        Commutativity
        Associativity
        Monotonicity
        BoundaryCondition_S(x,0)=x
    }
}

FUZZY_COMPLEMENT {
    STANDARD :=
        μ_notA(x) = 1 - μ_A(x)
}

FUZZY_INTERSECTION {
    USING_MIN :=
        μ_(A∩B)(x) =
            min(μ_A(x),μ_B(x))

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

FUZZY_UNION {
    USING_MAX :=
        μ_(A∪B)(x) =
            max(μ_A(x),μ_B(x))

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

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

    REQUIRE :=
        alpha ∈ [0,1]
}

STRONG_ALPHA_CUT {
    A_alpha_plus :=
        {x ∈ 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)
}

NORMAL_FUZZY_SET {
    A IS normal
    IFF
        EXISTS x:
            μ_A(x)=1
}

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

LINGUISTIC_VARIABLE {
    TYPE := Variable
    VALUES := FuzzyLinguisticTerms

    EXAMPLE_STRUCTURE {
        VARIABLE := Temperature
        TERMS := {Cold,Warm,Hot}
    }
}

ENTITY LinguisticTerm {
    TYPE := LabelledFuzzySet
}

MEMBERSHIP_FUNCTION_SHAPES {
    COMMON_FORMS := {
        Triangular,
        Trapezoidal,
        Gaussian,
        GeneralisedBell,
        Sigmoidal
    }
}

TRIANGULAR_MEMBERSHIP(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_MEMBERSHIP(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)
}

FUZZY_PROPOSITION {
    FORM :=
        "x is A"

    TRUTH_DEGREE :=
        μ_A(x)
}

FUZZY_RULE {
    FORM :=
        IF antecedent
        THEN consequent
}

ENTITY FuzzyRuleBase {
    TYPE := SetOfFuzzyRules
}

FUZZY_INFERENCE_SYSTEM {
    COMPONENTS := {
        Fuzzification,
        RuleBase,
        InferenceEngine,
        Aggregation,
        Defuzzification
    }
}

FUZZIFICATION(Input x, FuzzySets A1,...,An) {
    FOR_EACH Ai:
        COMPUTE μ_Ai(x)

    RETURN membership_degrees
}

RULE_ANTECEDENT_EVALUATION {
    IF antecedent = A AND B
    THEN
        strength := selected_t_norm(μ_A,μ_B)

    IF antecedent = A OR B
    THEN
        strength := selected_t_conorm(μ_A,μ_B)
}

MAMDANI_INFERENCE {
    RULE :=
        IF x IS A
        THEN y IS B

    firing_strength :=
        μ_A(x)

    implication_output :=
        clip_or_scale_B_according_to_selected_method

    AGGREGATE outputs_of_all_rules

    DEFUZZIFY aggregated_output
}

SUGENO_INFERENCE {
    RULE :=
        IF antecedent
        THEN
            y := f(inputs)

    OUTPUT :=
        weighted_combination_of_rule_consequents
}

CENTROID_DEFUZZIFICATION {
    crisp_output :=
        integral(y * μ_output(y) dy)
        /
        integral(μ_output(y) dy)

    REQUIRE :=
        denominator != 0
}

WEIGHTED_AVERAGE_DEFUZZIFICATION {
    output :=
        SUM_i(w_i*z_i)
        /
        SUM_i(w_i)

    REQUIRE :=
        SUM_i(w_i) != 0
}

FUZZY_IMPLICATION {
    TYPE := BinaryTruthFunction
    INPUTS := [0,1] × [0,1]
    OUTPUT := [0,1]

    NOTE :=
        multiple implication operators exist;
        selected semantics MUST be declared
}

MAMDANI_IMPLICATION {
    I_M(a,b) :=
        min(a,b)
        under common clipping interpretation
}

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

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

FUZZY_EQUIVALENCE {
    REQUIRE :=
        explicitly selected equivalence/similarity operator
}

DE_MORGAN_STYLE_RELATION {
    IF negation N,
       t_norm T,
       t_conorm S
       form compatible dual operators
    THEN
        N(T(x,y)) =
            S(N(x),N(y))
        MAY hold
}

MONOTONICITY {
    FOR t_norm T:
        x1<=x2 AND y1<=y2
        ->
        T(x1,y1)<=T(x2,y2)

    FOR t_conorm S:
        x1<=x2 AND y1<=y2
        ->
        S(x1,y1)<=S(x2,y2)
}

BOOLEAN_BOUNDARY_BEHAVIOUR {
    FOR x,y ∈ {0,1}:

    min_t_norm behaves_as BooleanAND
    max_t_conorm behaves_as BooleanOR
    standard_negation behaves_as BooleanNOT
}

FUZZY_RELATION {
    TYPE := FuzzySetOverCartesianProduct

    μ_R(x,y) ∈ [0,1]
}

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

FUZZY_SIMILARITY_RELATION {
    MAY_REQUIRE {
        Reflexivity,
        Symmetry,
        TransitivityVariant
    }

    REQUIRE :=
        selected fuzzy relation definition
}

FUZZY_NUMBER {
    TYPE := FuzzySetOnNumericDomain

    COMMON_PROPERTIES_MAY_INCLUDE {
        Normality,
        Convexity,
        UpperSemicontinuity,
        BoundedSupport
    }
}

EXTENSION_PRINCIPLE {
    GIVEN function f:X->Y
    AND fuzzy_set A on X

    induced_membership_on_Y :=
        supremum_of_memberships_of_preimages
        under standard Zadeh extension principle
}

APPROXIMATE_REASONING {
    INPUT := imprecise_or_linguistic_information
    PROCESS := fuzzy_rule_inference
    OUTPUT := graded_conclusion_or_crisp_decision
}

FUZZY_CONTROL {
    SENSOR_INPUT
        -> FUZZIFICATION
        -> RULE_EVALUATION
        -> AGGREGATION
        -> DEFUZZIFICATION
        -> CONTROL_OUTPUT
}

FUZZY_CLASSIFICATION {
    OBJECT x
        -> membership_degrees_across_classes
        -> graded_class_association
}

FUZZY_DECISION_MAKING {
    CRITERIA
        -> fuzzy_scores
        -> aggregation
        -> ranking_or_selection_method

    REQUIRE :=
        decision aggregation method explicitly defined
}

FUZZY_LOGIC_VS_BOOLEAN_LOGIC {
    BOOLEAN :=
        truth_domain {0,1}

    FUZZY :=
        graded_truth_domain commonly [0,1]

    RELATIONSHIP :=
        Boolean truth values form boundary/special cases
}

FUZZY_LOGIC_VS_PROBABILITY {
    FUZZY :=
        degree_of_truth_or_membership

    PROBABILITY :=
        degree_of_uncertainty_about_events

    CONSTRAINT :=
        numerical equality of values does not imply semantic equivalence
}

FUZZY_LOGIC_VS_MANY_VALUED_LOGIC {
    FuzzyLogic --is_related_to--> ManyValuedLogic

    DISTINCTION :=
        fuzzy logic commonly includes graded-set semantics,
        continuous truth degrees and fuzzy inference machinery
}

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

TYPE_2_FUZZY_SET {
    MEMBERSHIP_DEGREE :=
        itself represented fuzzily

    REQUIRE :=
        type_2_semantics explicitly defined
}

INTERVAL_TYPE_2_RELATIONSHIP {
    Type2FuzzySet --specialises_to--> IntervalType2FuzzySet
}

APPLICATION_RELATIONSHIPS {
    FuzzyLogic --supports--> ControlSystems
    FuzzyLogic --supports--> ApproximateReasoning
    FuzzyLogic --supports--> DecisionSupport
    FuzzyLogic --supports--> PatternRecognition
    FuzzyLogic --supports--> Classification
    FuzzyLogic --supports--> ExpertSystems
    FuzzyLogic --supports--> ArtificialIntelligence
    FuzzyLogic --supports--> Robotics
    FuzzyLogic --supports--> ImageProcessing
    FuzzyLogic --supports--> DataAnalysis
}

ONTOLOGY_LINKS {
    PARENT := MathematicalLogicOntologies

    RELATED := {
        BooleanLogicOntology,
        ManyValuedLogicOntology,
        SetTheoryOntology,
        FuzzySetOntology,
        MembershipFunctionOntology,
        FuzzyRelationOntology,
        ApproximateReasoningOntology,
        ProbabilityOntology,
        DecisionTheoryOntology,
        ArtificialIntelligenceOntology
    }
}

SEMANTIC_EQUIVALENCE {
    FuzzyTruthValue ≈ DegreeOfTruth
    MembershipDegree ≈ FuzzySetMembershipValue

    FuzzyAND ≈ TNorm
        WHEN selected_conjunction_operator_is_a_t_norm

    FuzzyOR ≈ TConorm
        WHEN selected_disjunction_operator_is_a_t_conorm

    StandardFuzzyNOT(x) ≈ 1-x
        WHEN standard_negation_is_selected
}

CONSTRAINTS {
    C1 :=
        fuzzy truth or membership values MUST remain within the declared truth domain

    C2 :=
        membership degree MUST NOT automatically be interpreted as probability

    C3 :=
        selected t-norm, t-conorm, negation and implication operators MUST be declared where results depend on them

    C4 :=
        different fuzzy inference systems MUST NOT be conflated

    C5 :=
        defuzzification method MUST be stated when a crisp output is derived

    C6 :=
        linguistic labels MUST be grounded by membership functions or equivalent semantics

    C7 :=
        fuzzy rule conclusions MUST preserve the selected inference semantics

    C8 :=
        Type-1 and Type-2 fuzzy sets MUST remain distinct

    C9 :=
        Boolean identities MUST NOT be assumed over arbitrary fuzzy operators unless mathematically valid

    C10 :=
        semantic equivalence claims MUST preserve both numerical and interpretive meaning
}

REASONING_CHAIN Query Q {
    IDENTIFY fuzzy_logic_context
    IDENTIFY universe_of_discourse
    IDENTIFY fuzzy_variables
    IDENTIFY membership_functions
    IDENTIFY operator_family

    IF crisp_input_provided
        THEN FUZZIFICATION

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

    IF rule_base_provided {
        COMPUTE antecedent_strengths
        COMPUTE rule_outputs
        AGGREGATE outputs
    }

    IF crisp_output_requested
        THEN APPLY declared_defuzzification_method

    IF alpha_cut_requested
        THEN compute thresholded_crisp_set

    IF fuzzy_relation_requested
        THEN apply declared_relation_composition

    IF comparison_with_probability
        THEN preserve semantic_distinction

    VALIDATE all_degrees_in_domain
    VALIDATE operator_assumptions
    RETURN result WITH derivation
}

CONFIDENCE {
    CORE_FUZZY_SET_DEFINITION := 1.00
    MEMBERSHIP_DOMAIN := 1.00
    STANDARD_MIN_MAX_NEGATION := 1.00
    TNORM_TCONORM_FRAMEWORK := 0.99
    MAMDANI_AND_SUGENO_DISTINCTION := 0.99

    INFERENCE_RESULT :=
        IF all_membership_functions_and_operators_specified THEN 1.00
        ELSE REQUIRE missing_information

    APPLICATION_SPECIFIC_INTERPRETATION :=
        REQUIRE contextual_validation
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        GradedTruthDomain,
        FuzzySetMembership,
        MembershipFunctionConcept,
        FuzzyOperatorDistinction
    }

    EXTENSIBLE := {
        TNormFamilies,
        TConormFamilies,
        Negations,
        Implications,
        MembershipFunctions,
        InferenceSystems,
        Type2Extensions,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY fuzzy_framework
        VALIDATE truth_domain
        VALIDATE membership_functions
        VALIDATE operator_axioms
        CHECK inference_compatibility
        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_RULE_INFERENCE := TRUE
    DEFUZZIFICATION_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 provides formal reasoning with graded truth and membership values, commonly over [0,1]. It combines fuzzy sets, membership functions, configurable conjunction/disjunction/negation operators and rule-based inference to represent vague concepts and derive graded or defuzzified conclusions while remaining semantically distinct from probability."
}

END_FLOW