Defuzzification Ontology

FLOW_ALGEBRA DefuzzificationOntology v1.0

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

BEGIN_FLOW

ENTITY Defuzzification {
    TYPE := FuzzyOutputTransformation
    DEFINITION := "The process of converting an aggregated fuzzy output set or equivalent fuzzy inference representation into a single crisp output value according to an explicitly selected method."
}

ENTITY FuzzyOutputSet {
    TYPE := FuzzySet
    MEMBERSHIP_FUNCTION := μ_out(y)
}

ENTITY CrispOutput {
    TYPE := ScalarOrDeclaredCrispValue
}

RELATIONSHIP Defuzzification --takes_input--> FuzzyOutputSet
RELATIONSHIP Defuzzification --produces--> CrispOutput
RELATIONSHIP Defuzzification --used_by--> FuzzyInferenceSystem
RELATIONSHIP Defuzzification --follows--> RuleAggregation
RELATIONSHIP Defuzzification --depends_on--> DefuzzificationMethod

PRECONDITION {
    INPUT :=
        aggregated_fuzzy_output_or_method_specific_equivalent

    REQUIRE :=
        output_domain_defined
}

POSTCONDITION {
    OUTPUT :=
        crisp_value y_star

    REQUIRE :=
        y_star belongs_to declared output domain
        OR declared extrapolation semantics
}

ENTITY CentroidMethod {
    TYPE := DefuzzificationMethod
    ALIASES := {CentreOfArea,CentreOfGravity}
}

CENTROID_CONTINUOUS {
    y_star :=
        integral_Y (
            y * μ_out(y)
        ) dy
        /
        integral_Y (
            μ_out(y)
        ) dy

    REQUIRE :=
        denominator > 0
}

CENTROID_DISCRETE {
    y_star :=
        SUM_i (
            y_i * μ_out(y_i)
        )
        /
        SUM_i μ_out(y_i)

    REQUIRE :=
        SUM_i μ_out(y_i) > 0
}

CENTROID_INTERPRETATION {
    OUTPUT :=
        membership-weighted centre of aggregated fuzzy area
}

ENTITY BisectorMethod {
    TYPE := DefuzzificationMethod
}

BISECTOR {
    FIND y_star SUCH_THAT
        integral_lower_to_y_star μ_out(y)dy
        =
        integral_y_star_to_upper μ_out(y)dy

    INTERPRETATION :=
        divides total fuzzy area into two equal areas
}

ENTITY MeanOfMaxima {
    ABBREVIATION := MOM
    TYPE := DefuzzificationMethod
}

MEAN_OF_MAXIMA {
    max_mu := sup_y μ_out(y)
    maxima_set :=
        {y | μ_out(y)=max_mu}

    y_star :=
        mean(maxima_set)
        WHEN mean is defined
}

ENTITY SmallestOfMaxima {
    ABBREVIATION := SOM
    TYPE := DefuzzificationMethod
}

SMALLEST_OF_MAXIMA {
    max_mu := sup_y μ_out(y)
    y_star :=
        inf{y | μ_out(y)=max_mu}
}

ENTITY LargestOfMaxima {
    ABBREVIATION := LOM
    TYPE := DefuzzificationMethod
}

LARGEST_OF_MAXIMA {
    max_mu := sup_y μ_out(y)
    y_star :=
        sup{y | μ_out(y)=max_mu}
}

MAXIMUM_METHOD_RELATIONSHIPS {
    MOM,SOM,LOM
        depend primarily on
        location_of_maximum_membership

    CENTROID,BISECTOR
        depend on
        broader aggregated membership shape
}

HEIGHT_METHOD {
    GIVEN output fuzzy sets B_i
    WITH representative values c_i
    AND heights h_i

    y_star :=
        SUM_i(h_i*c_i)
        /
        SUM_i h_i

    REQUIRE :=
        representative_value semantics declared
        AND denominator!=0
}

WEIGHTED_AVERAGE {
    y_star :=
        SUM_i(w_i*z_i)
        /
        SUM_i(w_i)

    REQUIRE :=
        SUM_i(w_i)!=0

    NOTE :=
        commonly associated with Sugeno-style crisp consequents;
        it is not identical to centroid defuzzification of an aggregated fuzzy set
}

WEIGHTED_SUM {
    y_star :=
        SUM_i(w_i*z_i)

    REQUIRE :=
        selected system semantics justify lack of normalisation
}

MAMDANI_RELATIONSHIP {
    MamdaniInference
        -> ActivatedFuzzyConsequents
        -> AggregatedFuzzyOutput
        -> Defuzzification
        -> CrispOutput
}

SUGENO_RELATIONSHIP {
    SugenoInference
        -> CrispRuleConsequents
        -> WeightedCombination
        -> CrispOutput

    DISTINCTION :=
        standard Sugeno output combination is not ordinary fuzzy-set defuzzification
}

TSUKAMOTO_RELATIONSHIP {
    TsukamotoInference
        -> each rule produces crisp z_i through monotonic consequent inversion
        -> weighted_average
        -> crisp_output
}

INPUT_VALIDATION(FuzzyOutputSet A) {
    REQUIRE {
        μ_A(y) ∈ [0,1],
        output_domain_defined,
        aggregation_complete
    }
}

ZERO_AREA_CASE {
    IF integral μ_out(y)dy = 0
       OR discrete_sum_memberships=0
    THEN
        centroid := undefined

    REQUIRE :=
        declared fallback_policy
}

FALLBACK_POLICIES {
    POSSIBLE := {
        DefaultOutput,
        PreviousOutput,
        NeutralOutput,
        ErrorOrUndefined
    }

    REQUIRE :=
        system-specific declaration
}

NONUNIQUE_MAXIMUM {
    IF multiple y values share maximum membership
    THEN
        MOM,SOM,LOM may return different outputs
}

SYMMETRIC_OUTPUT_PROPERTY {
    IF μ_out(y) is symmetric about centre c
       AND centroid exists
    THEN
        centroid := c
}

TRANSLATION_PROPERTY {
    IF fuzzy_output is translated by constant k
    THEN
        centroid translates by k
        when integrability assumptions hold
}

SCALING_MEMBERSHIP_HEIGHT {
    IF μ'_out(y)=c*μ_out(y)
       FOR constant c>0
       AND values remain valid for calculation
    THEN
        centroid_location unchanged

    REASON :=
        numerator and denominator scale equally
}

DISCRETISATION {
    ContinuousFuzzyOutput
        -> sample grid
        -> approximate defuzzification

    REQUIRE :=
        sampling_resolution sufficient for intended accuracy
}

NUMERICAL_CENTROID(OutputSamples {(y_i,μ_i)}) {
    numerator := SUM_i y_i*μ_i
    denominator := SUM_i μ_i

    IF denominator=0
        RETURN fallback_or_undefined

    RETURN numerator/denominator
}

NUMERICAL_BISECTOR(OutputSamples) {
    COMPUTE cumulative_membership_area
    FIND position where cumulative_area
        reaches half_total_area
    RETURN interpolated_position_if_required
}

METHOD_SELECTION {
    INPUT := {
        InferenceArchitecture,
        OutputShape,
        ComputationalConstraints,
        InterpretabilityRequirements,
        ContinuityRequirements
    }

    OUTPUT :=
        selected_defuzzification_method
}

METHOD_DEPENDENCE {
    SAME fuzzy_output
        + DIFFERENT defuzzification_method
        -> MAY produce different crisp_output
}

OUTPUT_SENSITIVITY {
    CHANGE fuzzy_output_shape
        -> MAY CHANGE defuzzified_value

    CHANGE method
        -> MAY CHANGE defuzzified_value
}

CONTINUITY_CONSIDERATION {
    Centroid
        often yields smoothly varying outputs
        when fuzzy output changes smoothly

    REQUIRE :=
        system-specific verification
}

COMPUTATIONAL_COMPLEXITY {
    DEPENDS_ON := {
        OutputRepresentation,
        NumberOfSamples,
        NumberOfRules,
        IntegrationMethod,
        DefuzzificationMethod
    }
}

EXACT_VS_NUMERICAL {
    ANALYTIC_MEMBERSHIP_FUNCTIONS
        MAY permit exact integration

    COMPLEX_AGGREGATED_OUTPUTS
        MAY require numerical approximation
}

MULTI_OUTPUT_SYSTEM {
    FOR_EACH output_variable y_j:
        defuzzify corresponding aggregated fuzzy output separately
        unless coupled output semantics explicitly defined
}

OUTPUT_RANGE_CHECK {
    AFTER defuzzification:
        VERIFY y_star within allowed actuator/decision/output range

    IF outside:
        APPLY declared saturation_or_validation_policy
}

SATURATION {
    clipped_output :=
        min(max(y_star,lower_bound),upper_bound)

    REQUIRE :=
        saturation policy explicitly selected
}

TYPE_2_RELATIONSHIP {
    Type2FuzzyInference
        -> TypeReduction
        -> Type1SetOrInterval
        -> Defuzzification
}

TYPE_REDUCTION_PRECEDENCE {
    REQUIRE :=
        Type2 output MUST undergo selected type-reduction process before standard crisp defuzzification
}

INTERVAL_OUTPUT {
    TypeReducedInterval :=
        [y_L,y_R]

    COMMON_CRISP_REDUCTION :=
        (y_L+y_R)/2

    REQUIRE :=
        selected Type-2 method
}

DEFUZZIFICATION_TRACE {
    RECORD {
        Method,
        OutputDomain,
        AggregatedMembershipRepresentation,
        NumeratorIfApplicable,
        DenominatorIfApplicable,
        MaximaSetIfApplicable,
        FallbackPolicy,
        CrispOutput
    }
}

VALIDATE_RESULT {
    CHECK {
        input_membership_range,
        denominator_nonzero_if_required,
        domain_consistency,
        method_preconditions,
        output_range
    }
}

DEFUZZIFICATION_VS_FUZZIFICATION {
    Fuzzification :=
        CrispInput -> FuzzyMembershipDegrees

    Defuzzification :=
        FuzzyOutputRepresentation -> CrispOutput

    THEY_ARE_NOT strict mathematical inverses in general
}

DEFUZZIFICATION_VS_THRESHOLDING {
    Defuzzification :=
        derive representative crisp output from fuzzy output

    Thresholding :=
        convert degree/value using a decision boundary

    MUST_REMAIN_DISTINCT := TRUE
}

DEFUZZIFICATION_VS_PROBABILITY_EXPECTATION {
    Centroid_formula
        may resemble weighted expectation mathematically

    BUT
        membership_function is not automatically a probability_density

    MUST_REMAIN_SEMANTICALLY_DISTINCT := TRUE
}

CONTROL_APPLICATION {
    AggregatedControlFuzzySet
        -> Defuzzification
        -> CrispActuatorCommand
}

DECISION_APPLICATION {
    FuzzyDecisionOutput
        -> Defuzzification
        -> CrispDecisionScore
}

APPLICATION_RELATIONSHIPS {
    Defuzzification --supports--> FuzzyControl
    Defuzzification --supports--> DecisionSupport
    Defuzzification --supports--> ExpertSystems
    Defuzzification --supports--> Robotics
    Defuzzification --supports--> ProcessControl
    Defuzzification --supports--> ArtificialIntelligence
    Defuzzification --supports--> FuzzyInference
}

ONTOLOGY_LINKS {
    PARENT := FuzzyLogicOntology

    RELATED := {
        FuzzyInferenceOntology,
        FuzzyRuleOntology,
        FuzzySetOntology,
        MembershipFunctionOntology,
        DegreeOfTruthOntology,
        MamdaniInferenceOntology,
        SugenoInferenceOntology,
        Type2FuzzySetOntology,
        ApproximateReasoningOntology
    }
}

SEMANTIC_EQUIVALENCE {
    Defuzzification ≈ CrispOutputExtraction
        WHEN context=fuzzy_inference

    CentroidMethod ≈ CentreOfArea
    CentroidMethod ≈ CentreOfGravity
        WHEN referring to standard fuzzy centroid

    MOM ≈ MeanOfMaxima
    SOM ≈ SmallestOfMaxima
    LOM ≈ LargestOfMaxima
}

CONSTRAINTS {
    C1 :=
        defuzzification method MUST be explicitly identified

    C2 :=
        fuzzy output membership values MUST remain within declared membership domain

    C3 :=
        centroid denominator MUST be nonzero

    C4 :=
        zero-area/no-rule-output cases MUST use an explicit fallback policy

    C5 :=
        Sugeno weighted output MUST NOT be conflated with centroid defuzzification

    C6 :=
        Type-2 outputs MUST undergo appropriate type reduction before ordinary crisp defuzzification

    C7 :=
        maximum-based methods MUST define behaviour for multiple maxima

    C8 :=
        numerical approximation MUST preserve sufficient resolution for intended accuracy

    C9 :=
        defuzzified output MUST be validated against declared output range

    C10 :=
        fuzzy membership MUST NOT be treated as probability density by default

    C11 :=
        defuzzification and thresholding MUST remain distinct

    C12 :=
        transformations MUST preserve the selected inference architecture and output semantics
}

REASONING_CHAIN Query Q {
    IDENTIFY fuzzy_output_representation
    IDENTIFY inference_architecture
    IDENTIFY output_domain
    IDENTIFY requested_defuzzification_method

    VALIDATE fuzzy_output

    IF method=Centroid {
        COMPUTE weighted_area_numerator
        COMPUTE membership_area_denominator
        IF denominator=0
            APPLY fallback
        ELSE
            RETURN numerator/denominator
    }

    IF method=Bisector
        THEN find equal_area_split

    IF method=MOM
        THEN compute mean_of_maxima

    IF method=SOM
        THEN choose smallest_maximum_location

    IF method=LOM
        THEN choose largest_maximum_location

    IF Sugeno_context
        THEN compute weighted_consequent_output
        AND label as Sugeno output combination

    IF Type2_context {
        APPLY type_reduction
        THEN apply selected crisp_reduction
    }

    VALIDATE output_range
    BUILD defuzzification_trace
    RETURN crisp_output WITH derivation
}

CONFIDENCE {
    CORE_DEFUZZIFICATION_DEFINITION := 1.00
    CENTROID_METHOD := 1.00
    BISECTOR_METHOD := 1.00
    MAXIMA_METHODS := 1.00
    SUGENO_DISTINCTION := 1.00
    TYPE2_PRECEDENCE := 0.99

    COMPUTED_OUTPUT :=
        IF fuzzy_output_and_method_complete THEN 1.00
        ELSE REQUIRE missing_information
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        FuzzyToCrispTransformation,
        MethodDependence,
        CentroidDefinition,
        ZeroAreaConstraint
    }

    EXTENSIBLE := {
        DefuzzificationMethods,
        NumericalIntegrationMethods,
        FallbackPolicies,
        Type2OutputMethods,
        OutputValidation,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY output_architecture
        VALIDATE membership_representation
        VALIDATE method_preconditions
        CHECK denominator_or_maxima_conditions
        CHECK output_domain
        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
    DEFUZZIFICATION_REASONING := TRUE
    CENTROID_REASONING := TRUE
    BISECTOR_REASONING := TRUE
    MAXIMA_REASONING := TRUE
    NUMERICAL_APPROXIMATION := TRUE
    TYPE2_OUTPUT_REASONING := TRUE
    OUTPUT_VALIDATION := TRUE
    TRACE_GENERATION := TRUE
}

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

OUTPUT {
    PRIMARY_ENTITY := Defuzzification

    INTERPRETATION :=
        "Defuzzification converts an aggregated fuzzy output representation into a crisp value using a declared method. Centroid, bisector and maxima-based methods derive different representative values from the same fuzzy output, while Sugeno and Type-2 systems use distinct output-processing pipelines that must remain explicit for semantically valid inference."
}

END_FLOW