Fuzzy Rule Ontology

FLOW_ALGEBRA FuzzyRuleOntology v1.0

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

BEGIN_FLOW

ENTITY FuzzyRule {
    TYPE := GradedInferenceRule
    DEFINITION := "A conditional rule in a fuzzy inference system whose antecedent and/or consequent are expressed using fuzzy propositions, linguistic terms or graded truth conditions."
    CANONICAL_FORM := IF Antecedent THEN Consequent
}

ENTITY Antecedent {
    TYPE := FuzzyCondition
}

ENTITY Consequent {
    TYPE := FuzzyConclusion
}

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

RELATIONSHIP FuzzyRule --has_part--> Antecedent
RELATIONSHIP FuzzyRule --has_part--> Consequent
RELATIONSHIP Antecedent --evaluates_to--> RuleFiringStrength
RELATIONSHIP FuzzyRule --belongs_to--> FuzzyRuleBase
RELATIONSHIP FuzzyRule --used_by--> FuzzyInferenceSystem
RELATIONSHIP FuzzyRule --depends_on--> MembershipFunction

BASIC_RULE_FORM {
    IF x IS A
    THEN y IS B
}

MULTI_ANTECEDENT_RULE {
    IF x IS A
       AND z IS C
    THEN y IS B
}

DISJUNCTIVE_RULE {
    IF x IS A
       OR z IS C
    THEN y IS B
}

NEGATED_ANTECEDENT {
    IF x IS NOT A
    THEN y IS B
}

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

ANTECEDENT_ATOM_EVALUATION {
    degree(x IS A) := μ_A(x)
}

ANTECEDENT_AND {
    degree(P AND Q) :=
        T(degree(P),degree(Q))

    REQUIRE selected_t_norm T
}

ANTECEDENT_OR {
    degree(P OR Q) :=
        S(degree(P),degree(Q))

    REQUIRE selected_t_conorm S
}

ANTECEDENT_NOT {
    degree(NOT P) :=
        N(degree(P))

    REQUIRE selected_negation N
}

RULE_FIRING_STRENGTH {
    w_i :=
        degree(Antecedent_i)
}

MIN_CONJUNCTION_EXAMPLE {
    IF antecedent := P AND Q
    AND selected_t_norm := min

    THEN
        w := min(degree(P),degree(Q))
}

PRODUCT_CONJUNCTION_EXAMPLE {
    IF antecedent := P AND Q
    AND selected_t_norm := product

    THEN
        w := degree(P)*degree(Q)
}

MAX_DISJUNCTION_EXAMPLE {
    IF antecedent := P OR Q
    AND selected_t_conorm := max

    THEN
        w := max(degree(P),degree(Q))
}

RULE_WEIGHT {
    TYPE := OptionalRuleParameter
    DOMAIN := commonly [0,1]

    EFFECT :=
        modify firing_strength according_to declared inference semantics
}

WEIGHTED_FIRING_STRENGTH {
    adjusted_w_i :=
        COMBINE(
            antecedent_strength_i,
            rule_weight_i
        )

    REQUIRE :=
        combination_method explicitly defined
}

ENTITY FuzzyRuleBase {
    TYPE := CollectionOfFuzzyRules
}

RULE_BASE {
    R := {R1,R2,...,Rn}
}

RELATIONSHIP FuzzyRuleBase --contains--> FuzzyRule
RELATIONSHIP FuzzyRuleBase --component_of--> FuzzyInferenceSystem

RULE_BASE_COVERAGE {
    PURPOSE :=
        provide meaningful rule responses across relevant input regions
}

RULE_BASE_CONSISTENCY {
    CHECK :=
        rules with overlapping antecedents and incompatible consequents

    NOTE :=
        overlap is not automatically an error;
        fuzzy aggregation may intentionally combine rules
}

RULE_REDUNDANCY {
    RULE R_i MAY be redundant
    IF
        removing R_i does not materially change inference under declared semantics

    REQUIRE :=
        explicit equivalence or performance criterion
}

RULE_CONFLICT {
    GIVEN R1,R2

    IF antecedents activate together
       AND consequents are strongly incompatible
    THEN
        potential_rule_conflict := TRUE

    REQUIRE :=
        declared incompatibility measure
}

MAMDANI_RULE {
    FORM :=
        IF x IS A
        THEN y IS B

    ANTECEDENT :=
        fuzzy_set_condition

    CONSEQUENT :=
        fuzzy_set B
}

MAMDANI_IMPLICATION_MIN {
    output_membership_i(y) :=
        min(
            w_i,
            μ_Bi(y)
        )
}

MAMDANI_IMPLICATION_PRODUCT {
    output_membership_i(y) :=
        w_i * μ_Bi(y)
}

MAMDANI_AGGREGATION_MAX {
    μ_aggregated(y) :=
        max_i output_membership_i(y)
}

MAMDANI_PIPELINE {
    CrispInputs
        -> Fuzzification
        -> AntecedentEvaluation
        -> RuleFiring
        -> ConsequentActivation
        -> RuleAggregation
        -> Defuzzification
        -> CrispOutput
}

SUGENO_RULE_ZERO_ORDER {
    FORM :=
        IF antecedent
        THEN z_i := constant_i
}

SUGENO_RULE_FIRST_ORDER {
    FORM :=
        IF antecedent
        THEN
            z_i :=
                a_i0
                + a_i1*x1
                + ...
                + a_in*xn
}

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

    REQUIRE :=
        SUM_i(w_i)!=0
}

MAMDANI_VS_SUGENO {
    MAMDANI_CONSEQUENT :=
        fuzzy_set

    SUGENO_CONSEQUENT :=
        crisp_function_or_constant

    CONSTRAINT :=
        consequent semantics MUST remain distinct
}

FUZZIFICATION_RELATIONSHIP {
    CrispInput
        -> MembershipFunctions
        -> AntecedentDegrees
        -> RuleFiringStrengths
}

DEFUZZIFICATION_RELATIONSHIP {
    MamdaniAggregatedFuzzyOutput
        -> Defuzzification
        -> CrispOutput
}

RULE_CHAINING {
    IF output fuzzy variable of one rule stage
       becomes input to another rule stage
    THEN
        fuzzy_rule_chaining MAY occur

    REQUIRE :=
        declared inference architecture
}

COMPOSITIONAL_RULE_OF_INFERENCE {
    FuzzyRelation
        + FuzzyInput
        -> ComposedFuzzyOutput

    REQUIRE :=
        selected fuzzy relation composition
}

GENERALIZED_MODUS_PONENS {
    GIVEN:
        Rule: IF x IS A THEN y IS B
        Fact: x IS A'

    DERIVE:
        y IS B'

    WHERE:
        similarity/compatibility between A' and A
        influences B'

    REQUIRE :=
        fuzzy implication and composition semantics
}

GENERALIZED_MODUS_TOLLENS {
    MAY be defined in some fuzzy reasoning systems

    REQUIRE :=
        explicit implication and inference semantics
}

LINGUISTIC_HEDGE_IN_RULE {
    EXAMPLES := {
        VERY,
        SOMEWHAT,
        MORE_OR_LESS
    }

    EFFECT :=
        transform membership degree
}

VERY_HEDGE {
    common_form:
        μ_veryA(x) := μ_A(x)^2
}

SOMEWHAT_HEDGE {
    common_form:
        μ_somewhatA(x) := sqrt(μ_A(x))
}

RULE_WITH_HEDGE {
    IF temperature IS VERY_HOT
    THEN fan_speed IS HIGH
}

RULE_PRIORITY {
    TYPE := OptionalOrderingOrWeighting
    REQUIRE :=
        explicit priority semantics

    WARNING :=
        ordinary fuzzy aggregation does not imply symbolic override priority
}

RULE_CERTAINTY_FACTOR_DISTINCTION {
    RuleWeight
        MUST_NOT automatically equal
    ProbabilityOrCertaintyFactor

    REQUIRE :=
        semantic definition
}

RULE_INTERPOLATION {
    PURPOSE :=
        infer behaviour in sparse fuzzy rule bases

    REQUIRE :=
        selected fuzzy rule interpolation method
}

RULE_EXTRACTION {
    SOURCES_MAY_INCLUDE := {
        ExpertKnowledge,
        Data,
        LearnedModel,
        ExistingControlPolicy
    }
}

EXPERT_RULE_DESIGN {
    HumanExpert
        -> LinguisticVariables
        -> FuzzyTerms
        -> IF_THEN_Rules
}

DATA_DRIVEN_RULE_LEARNING {
    Dataset
        -> CandidateRules
        -> ParameterOptimisation
        -> RuleSelection
        -> Validation
}

RULE_PRUNING {
    INPUT := FuzzyRuleBase
    CRITERIA_MAY_INCLUDE := {
        LowActivation,
        Redundancy,
        MinimalContribution,
        ComplexityPenalty
    }

    OUTPUT :=
        ReducedRuleBase
}

RULE_COMPLEXITY {
    MEASURES_MAY_INCLUDE := {
        NumberOfRules,
        AntecedentsPerRule,
        NumberOfLinguisticTerms,
        RuleDepth,
        ParameterCount
    }
}

RULE_INTERPRETABILITY {
    DESIRABLE_PROPERTIES_MAY_INCLUDE := {
        LinguisticClarity,
        LimitedRuleCount,
        CoherentTerms,
        LimitedOverlap,
        ConsistentConsequents
    }
}

RULE_SENSITIVITY {
    CHANGE MembershipFunction
        -> CHANGE AntecedentDegree
        -> CHANGE FiringStrength
        -> MAY CHANGE Output

    CHANGE RuleWeight
        -> MAY CHANGE Output
}

RULE_EVALUATION(Rule R, InputVector X) {
    IDENTIFY antecedent_atoms
    FUZZIFY relevant inputs
    EVALUATE each antecedent_atom
    COMBINE degrees using declared operators
    APPLY optional rule_weight
    RETURN firing_strength
}

MAMDANI_RULE_EVALUATION(Rule R, Input X) {
    w := RULE_EVALUATION(R,X)
    activated_consequent :=
        APPLY declared_implication(
            w,
            consequent_membership_function
        )
    RETURN activated_consequent
}

SUGENO_RULE_EVALUATION(Rule R, Input X) {
    w := RULE_EVALUATION(R,X)
    z := evaluate_consequent_function(R,X)
    RETURN {weight:=w, consequent:=z}
}

RULE_BASE_EVALUATION(RuleBase RB, Input X) {
    FOR_EACH rule R_i IN RB:
        result_i := evaluate_according_to_rule_type(R_i,X)

    AGGREGATE all result_i
    RETURN fuzzy_or_crisp_output
}

NO_RULE_FIRES {
    IF FOR_ALL i:
        w_i=0

    THEN
        output_handling MUST follow declared inference-system policy

    POSSIBLE_POLICIES := {
        DefaultRule,
        PreviousOutput,
        NeutralOutput,
        ErrorOrUndefined
    }
}

RULE_COVERAGE_TEST(RuleBase RB, InputDomain D) {
    FOR representative_or_all X IN D:
        COMPUTE firing_strengths

        IF all_zero:
            MARK uncovered_region
}

RULE_CONFLICT_TEST(RuleBase RB) {
    FOR_EACH pair (Ri,Rj):
        ESTIMATE antecedent_overlap

        IF overlap_significant
           AND consequents_incompatible
        THEN
            MARK potential_conflict
}

RULE_EQUIVALENCE {
    R1 ≈ R2
    IF
        they induce equivalent inference behaviour
        under same membership functions,
        operators,
        inputs,
        aggregation and output semantics
}

FUZZY_RULE_VS_CLASSICAL_RULE {
    CLASSICAL_RULE :=
        antecedent typically Boolean true/false

    FUZZY_RULE :=
        antecedent may activate to degree in [0,1]

    CONSEQUENCE :=
        multiple fuzzy rules may contribute simultaneously
}

FUZZY_RULE_VS_PROBABILISTIC_RULE {
    FuzzyFiringStrength
        !=
    ProbabilityOfRuleBeingTrue

    UNLESS explicitly defined by hybrid semantics
}

APPLICATION_RELATIONSHIPS {
    FuzzyRule --supports--> FuzzyControl
    FuzzyRule --supports--> ExpertSystems
    FuzzyRule --supports--> ApproximateReasoning
    FuzzyRule --supports--> DecisionSupport
    FuzzyRule --supports--> Classification
    FuzzyRule --supports--> Robotics
    FuzzyRule --supports--> ArtificialIntelligence
    FuzzyRule --supports--> ProcessControl
    FuzzyRule --supports--> KnowledgeRepresentation
}

ONTOLOGY_LINKS {
    PARENT := FuzzyLogicOntology

    RELATED := {
        FuzzyLogicOntology,
        FuzzySetOntology,
        MembershipFunctionOntology,
        DegreeOfTruthOntology,
        TNormOntology,
        TConormOntology,
        FuzzyImplicationOntology,
        LinguisticVariableOntology,
        FuzzyInferenceSystemOntology,
        ApproximateReasoningOntology
    }
}

SEMANTIC_EQUIVALENCE {
    FuzzyRule ≈ FuzzyIFTHENRule
    RuleFiringStrength ≈ AntecedentActivationDegree
    RuleBase ≈ FuzzyKnowledgeBase
        WHEN context=rule_based_fuzzy_system

    AntecedentDegree ≈ RuleActivation
        WHEN no additional rule weighting is applied
}

CONSTRAINTS {
    C1 :=
        every fuzzy rule MUST have identifiable antecedent and consequent semantics

    C2 :=
        firing strength MUST remain within the declared degree domain

    C3 :=
        conjunction/disjunction/negation operators MUST be declared where results depend on them

    C4 :=
        Mamdani and Sugeno consequent semantics MUST NOT be conflated

    C5 :=
        rule weights MUST NOT automatically be interpreted as probabilities

    C6 :=
        aggregation method MUST be declared before deriving a combined output

    C7 :=
        defuzzification MUST be declared when converting Mamdani fuzzy output to crisp output

    C8 :=
        rule conflict MUST NOT be inferred merely from antecedent overlap

    C9 :=
        no-rule-fire behaviour MUST be explicitly handled

    C10 :=
        linguistic hedges MUST declare their membership transformation

    C11 :=
        learned or optimised rules MUST preserve fuzzy-domain constraints

    C12 :=
        all rule transformations MUST preserve selected inference semantics
}

REASONING_CHAIN Query Q {
    IDENTIFY fuzzy_rule_or_rule_base
    IDENTIFY inference_system_type
    IDENTIFY input_variables
    IDENTIFY membership_functions
    IDENTIFY antecedent_structure
    IDENTIFY consequent_structure
    IDENTIFY fuzzy_operators

    FUZZIFY crisp_inputs

    FOR_EACH rule {
        EVALUATE antecedent_atoms
        COMBINE using declared operators
        COMPUTE firing_strength
        APPLY optional rule_weight
    }

    IF Mamdani_context {
        ACTIVATE fuzzy_consequents
        AGGREGATE outputs
        IF crisp_output_requested
            THEN DEFUZZIFY
    }

    IF Sugeno_context {
        EVALUATE consequent_functions
        COMPUTE weighted_output
    }

    IF rule_base_analysis_requested {
        CHECK coverage
        CHECK redundancy
        CHECK potential_conflict
        CHECK interpretability
    }

    IF no_rule_fires
        THEN apply declared fallback_policy

    VALIDATE constraints
    RETURN result WITH derivation
}

CONFIDENCE {
    CORE_FUZZY_RULE_DEFINITION := 1.00
    FIRING_STRENGTH_CONCEPT := 1.00
    MAMDANI_RULE_SEMANTICS := 0.99
    SUGENO_RULE_SEMANTICS := 0.99
    GENERALIZED_MODUS_PONENS := 0.99

    RULE_OUTPUT :=
        IF membership_functions_operators_and_inference_method_complete THEN 1.00
        ELSE REQUIRE missing_information
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        AntecedentConsequentStructure,
        GradedRuleActivation,
        RuleBaseConcept,
        FuzzyInferenceDependency
    }

    EXTENSIBLE := {
        RuleTypes,
        RuleWeights,
        RuleLearning,
        RulePruning,
        RuleInterpolation,
        ConflictMeasures,
        InferenceArchitectures,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY rule_system
        VALIDATE antecedent_semantics
        VALIDATE consequent_semantics
        VALIDATE firing_strength_range
        CHECK operator_compatibility
        CHECK aggregation_semantics
        CHECK semantic_consistency
        ADD relationship IF non_contradictory
        UPDATE confidence
    }
}

AI_CONSUMPTION {
    MACHINE_READABLE := TRUE
    HUMAN_INTERPRETABLE := TRUE
    RECURSIVE_REASONING := TRUE
    ENTITY_RESOLUTION := TRUE
    RULE_RESOLUTION := TRUE
    SYMBOL_RESOLUTION := TRUE
    RELATIONSHIP_TRAVERSAL := TRUE
    FUZZIFICATION_REASONING := TRUE
    RULE_FIRING_REASONING := TRUE
    RULE_BASE_REASONING := TRUE
    MAMDANI_REASONING := TRUE
    SUGENO_REASONING := TRUE
    RULE_CONFLICT_DETECTION := TRUE
    RULE_COVERAGE_REASONING := TRUE
    DEFUZZIFICATION_REASONING := TRUE
    VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
    PRIMARY_ENTITY := FuzzyRule

    INTERPRETATION :=
        "A fuzzy rule is an IF-THEN inference structure whose antecedent activates to a graded strength derived from fuzzy membership values and selected logical operators. Rule bases combine multiple such rules through an explicit inference architecture, such as Mamdani or Sugeno, allowing overlapping linguistic conditions to contribute simultaneously to a graded or crisp system output."
}

END_FLOW