Membership Function Ontology

FLOW_ALGEBRA MembershipFunctionOntology v1.0

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

BEGIN_FLOW

ENTITY MembershipFunction {
    TYPE := Function
    SYMBOL := μ_A
    SIGNATURE := μ_A:X->[0,1]
    DEFINITION := "A function assigning each element of a universe of discourse a degree of membership in a fuzzy set."
}

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

ENTITY FuzzySet {
    TYPE := GeneralisedSet
    DEFINED_BY := MembershipFunction
}

ENTITY UniverseOfDiscourse {
    TYPE := Domain
    SYMBOL := X
}

RELATIONSHIP MembershipFunction --defines--> FuzzySet
RELATIONSHIP MembershipFunction --maps_from--> UniverseOfDiscourse
RELATIONSHIP MembershipFunction --maps_to--> MembershipDegree
RELATIONSHIP MembershipFunction --supports--> Fuzzification
RELATIONSHIP MembershipFunction --supports--> LinguisticVariable
RELATIONSHIP MembershipFunction --used_by--> FuzzyInferenceSystem

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

    μ_A(x)=0 :=
        no_membership_in_A

    μ_A(x)=1 :=
        full_membership_in_A

    0<μ_A(x)<1 :=
        partial_membership_in_A
}

CRISP_SET_SPECIAL_CASE {
    IF μ_A(x)∈{0,1} FOR_ALL x
    THEN
        A behaves_as_crisp_set
}

SEMANTIC_DISTINCTION {
    MembershipDegree != Probability
    MembershipDegree != StatisticalConfidence
    MembershipDegree != Frequency

    REQUIRE :=
        interpretation_as_fuzzy_membership
}

ENTITY ParametricMembershipFunction {
    TYPE := MembershipFunction
    PARAMETERS := finite_parameter_vector
}

COMMON_MEMBERSHIP_FUNCTIONS := {
    Triangular,
    Trapezoidal,
    Gaussian,
    GeneralisedBell,
    Sigmoidal,
    Singleton,
    PiecewiseLinear
}

TRIANGULAR_MEMBERSHIP {
    PARAMETERS := a,b,c
    REQUIRE := a<=b<=c

    μ(x) :=
        0                    IF x<=a
        (x-a)/(b-a)          IF a<x<=b
        (c-x)/(c-b)          IF b<x<c
        0                    IF x>=c

    PEAK :=
        μ(b)=1
        under nondegenerate parameters
}

TRAPEZOIDAL_MEMBERSHIP {
    PARAMETERS := a,b,c,d
    REQUIRE := a<=b<=c<=d

    μ(x) :=
        0                    IF x<=a
        (x-a)/(b-a)          IF a<x<b
        1                    IF b<=x<=c
        (d-x)/(d-c)          IF c<x<d
        0                    IF x>=d
}

GAUSSIAN_MEMBERSHIP {
    PARAMETERS := centre_c, sigma
    REQUIRE := sigma>0

    μ(x) :=
        exp(
            -((x-c)^2)/(2*sigma^2)
        )

    PROPERTY :=
        μ(c)=1
}

GENERALISED_BELL_MEMBERSHIP {
    PARAMETERS := a,b,c
    REQUIRE := a!=0

    μ(x) :=
        1 /
        (
            1 + abs((x-c)/a)^(2b)
        )
}

SIGMOIDAL_MEMBERSHIP {
    PARAMETERS := a,c

    μ(x) :=
        1 /
        (
            1 + exp(-a(x-c))
        )
}

SINGLETON_MEMBERSHIP {
    PARAMETER := c

    μ(x) :=
        1 IF x=c
        ELSE 0
}

PIECEWISE_LINEAR_MEMBERSHIP {
    CONTROL_POINTS :=
        {(x1,μ1),...,(xn,μn)}

    INTERPOLATE :=
        linearly_between_adjacent_control_points

    REQUIRE :=
        every μi∈[0,1]
}

SUPPORT {
    support(A) :=
        {x∈X | μ_A(x)>0}
}

CORE {
    core(A) :=
        {x∈X | μ_A(x)=1}
}

BOUNDARY {
    boundary(A) :=
        {x∈X | 0<μ_A(x)<1}
}

HEIGHT {
    height(A) :=
        sup_x μ_A(x)
}

NORMAL_MEMBERSHIP_FUNCTION {
    NORMAL :=
        height(A)=1
}

SUBNORMAL_MEMBERSHIP_FUNCTION {
    SUBNORMAL :=
        height(A)<1
}

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

    REQUIRE :=
        alpha∈[0,1]
}

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

ALPHA_CUT_NESTING {
    IF alpha1<=alpha2
    THEN
        A_alpha2 ⊆ A_alpha1
}

FUZZY_CONVEXITY {
    μ_A(λx+(1-λ)y)
        >=
    min(μ_A(x),μ_A(y))

    FOR_ALL x,y
    FOR_ALL λ∈[0,1]
}

CROSSOVER_POINT {
    x_c IS crossover_point
    IFF
        μ_A(x_c)=0.5
}

LINGUISTIC_VARIABLE {
    COMPONENTS := {
        VariableName,
        UniverseOfDiscourse,
        LinguisticTerms
    }
}

LINGUISTIC_TERM {
    TYPE := FuzzySet
    REPRESENTED_BY := MembershipFunction
}

EXAMPLE {
    VARIABLE := Temperature
    TERM := Warm
    MEMBERSHIP_FUNCTION := μ_Warm(temperature)
}

FUZZIFICATION {
    INPUT := crisp_value x

    FOR_EACH fuzzy_set A_i:
        degree_i := μ_Ai(x)

    OUTPUT :=
        {degree_1,...,degree_n}
}

OVERLAP {
    GIVEN fuzzy_sets A,B

    overlap_degree MAY be measured using
        selected similarity/intersection metric

    REQUIRE :=
        overlap_measure explicitly defined
}

PARTITION {
    FUZZY_PARTITION :=
        collection_of_fuzzy_sets_covering_universe

    REQUIRE :=
        selected partition constraints
}

RUSPINI_PARTITION {
    FOR_ALL x:
        SUM_i μ_Ai(x)=1

    NOTE :=
        Ruspini partition is a specialised fuzzy partition condition
}

COMPLEMENT_MEMBERSHIP {
    USING standard_negation:
        μ_notA(x)=1-μ_A(x)
}

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

    REQUIRE :=
        selected_t_norm T
}

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

    REQUIRE :=
        selected_t_conorm S
}

MODIFIER_VERY {
    COMMON_HEDGE :=
        μ_veryA(x) = μ_A(x)^2

    NOTE :=
        hedge semantics may vary
}

MODIFIER_MORE_OR_LESS {
    COMMON_HEDGE :=
        μ_more_or_less_A(x) =
            sqrt(μ_A(x))

    NOTE :=
        hedge semantics may vary
}

CONCENTRATION {
    μ_CON(A)(x) :=
        μ_A(x)^p
    TYPICALLY p>1
}

DILATION {
    μ_DIL(A)(x) :=
        μ_A(x)^p
    TYPICALLY 0<p<1
}

MEMBERSHIP_CALIBRATION {
    INPUT := {
        ExpertKnowledge,
        Data,
        OptimisationObjective,
        Constraints
    }

    OUTPUT :=
        membership_function_parameters
}

EXPERT_DESIGN {
    HumanExpert
        -> choose linguistic boundaries
        -> choose shape
        -> choose parameters
}

DATA_DRIVEN_ESTIMATION {
    Dataset
        -> fit_membership_parameters
        -> validate_fuzzy_model
}

OPTIMISATION {
    PARAMETERS θ
        -> objective_function J(θ)
        -> optimisation_algorithm
        -> updated θ
}

CONSTRAINT_PRESERVATION {
    FOR_ALL fitted_membership_functions:
        μ(x) MUST remain in [0,1]
}

INTERPRETABILITY {
    DESIRABLE_PROPERTIES_MAY_INCLUDE := {
        OrderedTerms,
        LimitedOverlap,
        SemanticCoverage,
        StableLabels,
        SimpleShapes
    }
}

SENSITIVITY {
    CHANGE parameters
        -> CHANGE membership_degrees
        -> MAY CHANGE rule_firing_strengths
        -> MAY CHANGE fuzzy_inference_output
}

FUZZY_RULE_RELATIONSHIP {
    IF antecedent contains
        "x IS A"
    THEN
        antecedent_truth_degree :=
            μ_A(x)
}

MAMDANI_RELATIONSHIP {
    MembershipFunction
        --determines-->
        antecedent_firing_strength

    OutputMembershipFunction
        --represents-->
        fuzzy_consequent
}

SUGENO_RELATIONSHIP {
    InputMembershipFunctions
        --determine-->
        rule_firing_strengths

    Consequent :=
        crisp_function_or_constant
}

TYPE_1_MEMBERSHIP_FUNCTION {
    μ_A:X->[0,1]
}

TYPE_2_MEMBERSHIP_FUNCTION {
    μ_A(x,u)∈[0,1]

    WHERE
        u is a possible primary membership degree
}

INTERVAL_TYPE_2_MEMBERSHIP {
    primary_membership_interval :=
        [lower_mu_A(x), upper_mu_A(x)]
}

FOOTPRINT_OF_UNCERTAINTY {
    FOU :=
        union_of_all_primary_membership_intervals
}

DISCRETE_MEMBERSHIP_FUNCTION {
    DOMAIN :=
        finite_or_countable_set

    REPRESENTATION :=
        {(x_i, μ_A(x_i))}
}

CONTINUOUS_MEMBERSHIP_FUNCTION {
    DOMAIN :=
        continuous_numeric_or_other_continuous_space

    REPRESENTATION :=
        analytic_or_piecewise_function
}

MULTIDIMENSIONAL_MEMBERSHIP_FUNCTION {
    μ_A:X1×...×Xn->[0,1]
}

MEMBERSHIP_SURFACE {
    TYPE := VisualOrMathematicalRepresentation
    APPLIES_TO := multidimensional_membership_function
}

VALIDATE_MEMBERSHIP_FUNCTION(MF μ, Domain X) {
    FOR_ALL x∈X:
        REQUIRE 0<=μ(x)<=1

    CHECK parameter_constraints
    CHECK intended_continuity_if_required
    CHECK normality_if_required
    CHECK convexity_if_required

    RETURN validation_result
}

COMPARE_MEMBERSHIP_FUNCTIONS(A,B) {
    COMPARE {
        Support,
        Core,
        Height,
        AlphaCuts,
        Shape,
        Parameters,
        Overlap,
        Interpretability
    }

    RETURN structured_comparison
}

APPLICATION_RELATIONSHIPS {
    MembershipFunction --supports--> FuzzyClassification
    MembershipFunction --supports--> FuzzyControl
    MembershipFunction --supports--> DecisionSupport
    MembershipFunction --supports--> ExpertSystems
    MembershipFunction --supports--> PatternRecognition
    MembershipFunction --supports--> ApproximateReasoning
    MembershipFunction --supports--> ArtificialIntelligence
    MembershipFunction --supports--> DataFusion
}

ONTOLOGY_LINKS {
    PARENT := FuzzyLogicOntology

    RELATED := {
        FuzzySetOntology,
        FuzzyLogicOntology,
        LinguisticVariableOntology,
        TNormOntology,
        TConormOntology,
        FuzzyRelationOntology,
        FuzzyNumberOntology,
        Type2FuzzySetOntology,
        ApproximateReasoningOntology
    }
}

SEMANTIC_EQUIVALENCE {
    MembershipFunction ≈ FuzzyMembershipFunction
    MembershipDegree ≈ DegreeOfMembership
    μ_A(x) ≈ membership_of_x_in_A

    Core(A) ≈ FullMembershipRegion
    Support(A) ≈ PositiveMembershipRegion
}

CONSTRAINTS {
    C1 :=
        every membership degree MUST lie within [0,1] for standard Type-1 fuzzy sets

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

    C3 :=
        function shape and parameters MUST be declared when numerical evaluation depends on them

    C4 :=
        degenerate parameter cases MUST be handled explicitly to avoid undefined divisions

    C5 :=
        linguistic terms MUST preserve their declared semantic interpretation

    C6 :=
        Type-1 and Type-2 membership functions MUST remain distinct

    C7 :=
        complement, intersection and union operations MUST identify their selected fuzzy operators

    C8 :=
        fitted membership functions MUST satisfy required domain and structural constraints

    C9 :=
        normality and convexity MUST NOT be assumed unless established

    C10 :=
        transformations MUST preserve membership values and intended fuzzy semantics
}

REASONING_CHAIN Query Q {
    IDENTIFY target_membership_function
    IDENTIFY universe_of_discourse
    IDENTIFY fuzzy_set
    IDENTIFY membership_function_type
    IDENTIFY parameters

    VALIDATE parameter_constraints

    IF crisp_input_provided
        THEN evaluate μ_A(x)

    IF fuzzification_requested
        THEN evaluate all relevant membership_functions

    IF alpha_cut_requested
        THEN solve μ_A(x)>=alpha

    IF support_requested
        THEN solve μ_A(x)>0

    IF core_requested
        THEN solve μ_A(x)=1

    IF normality_requested
        THEN compute height

    IF convexity_requested
        THEN test fuzzy_convexity_condition

    IF comparison_requested
        THEN COMPARE_MEMBERSHIP_FUNCTIONS

    IF calibration_requested
        THEN identify data_or_expert_objective

    IF Type2_context
        THEN identify primary_and_secondary_membership_semantics

    VALIDATE membership_range
    RETURN result WITH derivation
}

CONFIDENCE {
    CORE_MEMBERSHIP_FUNCTION_DEFINITION := 1.00
    TYPE1_RANGE_CONSTRAINT := 1.00
    STANDARD_PARAMETRIC_FORMS := 1.00
    ALPHA_CUT_RELATIONSHIPS := 1.00
    FUZZIFICATION_ROLE := 1.00

    NUMERICAL_EVALUATION :=
        IF function_and_parameters_complete THEN 1.00
        ELSE REQUIRE missing_information

    DATA_DRIVEN_CALIBRATION :=
        REQUIRE model_and_objective_definition
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        MembershipMapping,
        DegreeDomain,
        FuzzySetDefinition,
        MembershipSemantics
    }

    EXTENSIBLE := {
        MembershipFunctionFamilies,
        Parameterisations,
        CalibrationMethods,
        LinguisticHedges,
        Type2Membership,
        SimilarityMeasures,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY membership_function_family
        VALIDATE domain
        VALIDATE range
        VALIDATE parameters
        CHECK fuzzy_set_semantics
        CHECK inference_compatibility
        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
    MEMBERSHIP_EVALUATION := TRUE
    FUZZIFICATION_REASONING := TRUE
    ALPHA_CUT_REASONING := TRUE
    PARAMETER_VALIDATION := TRUE
    MEMBERSHIP_COMPARISON := TRUE
    TYPE2_REASONING := TRUE
    VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
    PRIMARY_ENTITY := MembershipFunction

    INTERPRETATION :=
        "A membership function defines a fuzzy set by mapping each element of a universe of discourse to a membership degree, normally in [0,1]. Its shape and parameters determine how crisp inputs become graded fuzzy memberships and therefore directly influence fuzzy rules, inference, classification and control."
}

END_FLOW