Linguistic Variable Ontology

FLOW_ALGEBRA LinguisticVariableOntology v1.0

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

BEGIN_FLOW

ENTITY LinguisticVariable {
    TYPE := FuzzyVariable
    DEFINITION := "A variable whose values are linguistic terms represented by fuzzy sets over a universe of discourse."
    FORMAL_STRUCTURE := (Name,TermSet,Universe,SyntacticRule,SemanticRule)
}

ENTITY LinguisticTerm {
    TYPE := LabelledFuzzySet
}

ENTITY UniverseOfDiscourse {
    TYPE := Domain
}

ENTITY MembershipFunction {
    TYPE := Function
    SIGNATURE := X->[0,1]
}

RELATIONSHIP LinguisticVariable --has--> LinguisticTerm
RELATIONSHIP LinguisticVariable --defined_over--> UniverseOfDiscourse
RELATIONSHIP LinguisticTerm --represented_by--> FuzzySet
RELATIONSHIP FuzzySet --defined_by--> MembershipFunction
RELATIONSHIP LinguisticVariable --used_by--> FuzzyRule
RELATIONSHIP LinguisticVariable --used_by--> FuzzyInferenceSystem

FORMAL_COMPONENTS {
    X := variable_name
    T(X) := set_of_linguistic_terms
    U := universe_of_discourse
    G := syntactic_rule
    M := semantic_rule
}

EXAMPLE {
    VARIABLE := Temperature
    UNIVERSE := [0,100]
    TERMS := {Cold,Mild,Warm,Hot}

    EACH term A:
        μ_A:U->[0,1]
}

LINGUISTIC_VALUE {
    VALUE :=
        linguistic_label

    SEMANTICS :=
        associated_fuzzy_set
}

CRISP_INPUT_MAPPING {
    crisp_value x
        -> evaluate each term_membership_function
        -> degrees across linguistic_terms
}

FUZZIFICATION {
    FOR LinguisticVariable V
    AND crisp_value x:

    FOR_EACH term A IN T(V):
        degree_A := μ_A(x)

    RETURN {
        A1:degree_1,
        ...,
        An:degree_n
    }
}

MULTIPLE_MEMBERSHIP {
    A crisp input MAY have
        nonzero membership
        in multiple linguistic terms simultaneously
}

TERM_OVERLAP {
    GIVEN terms A,B

    overlap_region :=
        {x | μ_A(x)>0 AND μ_B(x)>0}

    NOTE :=
        overlap commonly enables smooth fuzzy transitions
}

TERM_CORE {
    core(A) :=
        {x | μ_A(x)=1}
}

TERM_SUPPORT {
    support(A) :=
        {x | μ_A(x)>0}
}

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

LINGUISTIC_PARTITION {
    TYPE := CollectionOfTermsOverCommonUniverse
}

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

    NOTE :=
        optional specialised partition property
}

COVERAGE {
    DESIRABLE_CONDITION :=
        FOR_ALL relevant x∈U:
            EXISTS term A:
                μ_A(x)>0
}

UNCOVERED_REGION {
    IF EXISTS x:
        FOR_ALL terms A:
            μ_A(x)=0

    THEN
        x lies in uncovered_linguistic_region
}

LINGUISTIC_HEDGE {
    TYPE := Modifier
    PURPOSE :=
        transform meaning of linguistic term
}

ENTITY VeryHedge {
    TYPE := LinguisticHedge
}

VERY {
    common_semantics:
        μ_veryA(x) :=
            μ_A(x)^2
}

ENTITY MoreOrLessHedge {
    TYPE := LinguisticHedge
}

MORE_OR_LESS {
    common_semantics:
        μ_more_or_less_A(x) :=
            sqrt(μ_A(x))
}

ENTITY NotHedge {
    TYPE := LinguisticHedge
}

NOT {
    under standard_negation:
        μ_notA(x) :=
            1-μ_A(x)
}

ENTITY ExtremelyHedge {
    TYPE := LinguisticHedge
}

EXTREMELY {
    possible_semantics:
        μ_extremelyA(x) :=
            μ_A(x)^p
        WHERE p>2

    REQUIRE :=
        exponent/hedge definition declared
}

HEDGE_COMPOSITION {
    VERY(VERY(A))
        -> μ_A(x)^4
        under square-concentration semantics
}

SYNTACTIC_RULE {
    PURPOSE :=
        generate valid compound linguistic terms

    EXAMPLES := {
        VeryHot,
        NotCold,
        MoreOrLessWarm
    }
}

SEMANTIC_RULE {
    PURPOSE :=
        map linguistic expression
        to fuzzy-set membership semantics
}

TERM_ORDERING {
    SOME linguistic variables
        MAY have ordered terms

    EXAMPLE :=
        Cold < Mild < Warm < Hot

    REQUIRE :=
        ordering justified by domain semantics
}

ORDINAL_LINGUISTIC_VARIABLE {
    TERMS :=
        ordered linguistic categories

    NOTE :=
        ordering does not by itself specify membership functions
}

NOMINAL_LINGUISTIC_VARIABLE {
    TERMS :=
        linguistic categories without intrinsic order
}

NUMERIC_UNIVERSE {
    U :=
        numeric interval_or_set
}

NONNUMERIC_UNIVERSE {
    U :=
        categorical_or_structured_domain

    REQUIRE :=
        valid membership semantics for domain
}

MEMBERSHIP_FUNCTION_TYPES {
    COMMON := {
        Triangular,
        Trapezoidal,
        Gaussian,
        Bell,
        Sigmoidal
    }
}

TERM_PARAMETERISATION {
    LinguisticTerm
        -> MembershipFunctionFamily
        -> Parameters
}

TERM_CALIBRATION {
    INPUT := {
        ExpertKnowledge,
        Data,
        OptimisationObjective
    }

    OUTPUT :=
        term_membership_parameters
}

EXPERT_DEFINED_TERMS {
    DomainExpert
        -> choose term labels
        -> define semantic ranges
        -> define membership_functions
}

DATA_DRIVEN_TERMS {
    Dataset
        -> estimate fuzzy partitions
        -> assign_or_validate linguistic labels
}

SEMANTIC_STABILITY {
    REQUIRE :=
        same linguistic label should retain coherent interpretation
        within a declared system/version
}

CONTEXT_DEPENDENCE {
    TERM "High"
        MAY represent different fuzzy sets
        for Temperature,
        Speed,
        Risk,
        Cost

    CONSTRAINT :=
        linguistic term meaning MUST be scoped to its variable and universe
}

UNIT_DEPENDENCE {
    IF universe uses physical quantity
    THEN
        units MUST be identified

    ConversionOfUnits
        -> transform universe
        -> transform membership parameters consistently
}

FUZZY_PROPOSITION {
    FORM :=
        V IS A

    TRUTH_DEGREE :=
        μ_A(value(V))
}

FUZZY_RULE_ANTECEDENT {
    IF Temperature IS Hot
       AND Humidity IS High
    THEN ...

    antecedent_degree :=
        selected_t_norm(
            μ_Hot(temperature),
            μ_High(humidity)
        )
}

FUZZY_RULE_CONSEQUENT {
    THEN FanSpeed IS Fast

    CONSEQUENT_TERM :=
        Fast fuzzy set over FanSpeed universe
}

MAMDANI_RELATIONSHIP {
    InputLinguisticTerms
        -> antecedent_firing_strength

    OutputLinguisticTerm
        -> fuzzy_consequent
}

SUGENO_RELATIONSHIP {
    InputLinguisticTerms
        -> antecedent_firing_strength

    Consequent
        -> crisp_function_or_constant

    NOTE :=
        output need not be a linguistic fuzzy term
}

LINGUISTIC_APPROXIMATION {
    INPUT :=
        fuzzy_set_or_numeric_result

    OUTPUT :=
        closest_or_best linguistic_description

    REQUIRE :=
        declared similarity/distance criterion
}

TERM_SIMILARITY {
    INPUT := terms A,B
    OUTPUT := similarity_degree
    REQUIRE selected_similarity_measure
}

TERM_DISTANCE {
    INPUT := terms A,B
    OUTPUT := distance
    REQUIRE selected_distance_measure
}

TERM_REDUNDANCY {
    IF two terms have near-identical fuzzy semantics
    THEN
        potential_redundancy := TRUE

    REQUIRE threshold/criterion declared
}

TERM_DISTINGUISHABILITY {
    DESIRABLE :=
        neighbouring terms sufficiently distinct
        for intended interpretability
}

GRANULARITY {
    TYPE := NumberAndResolutionOfLinguisticTerms

    LOW_GRANULARITY :=
        few broad terms

    HIGH_GRANULARITY :=
        many narrow terms
}

GRANULARITY_TRADEOFF {
    MoreTerms
        -> potentially finer representation
        -> potentially greater complexity
}

LINGUISTIC_HIERARCHY {
    COARSE_TERMS :=
        {Low,Medium,High}

    FINE_TERMS :=
        {VeryLow,Low,MediumLow,Medium,MediumHigh,High,VeryHigh}

    REQUIRE :=
        mappings between levels explicitly defined
}

TYPE_2_LINGUISTIC_VARIABLE {
    TERMS :=
        Type2FuzzySets

    PURPOSE :=
        represent uncertainty about membership functions themselves
}

INTERVAL_TYPE_2_TERM {
    MEMBERSHIP :=
        [lower_mu_A(x),upper_mu_A(x)]
}

LINGUISTIC_UNCERTAINTY {
    SOURCES_MAY_INCLUDE := {
        ExpertDisagreement,
        MeasurementAmbiguity,
        ContextVariation,
        SparseData
    }
}

INTERPRETABILITY_CHECK {
    CHECK {
        MeaningfulLabels,
        OrderedTermsIfApplicable,
        Coverage,
        Overlap,
        Redundancy,
        UnitConsistency,
        StableSemantics
    }
}

VALIDATE_LINGUISTIC_VARIABLE(V) {
    REQUIRE universe_defined
    REQUIRE term_set_nonempty

    FOR_EACH term A:
        REQUIRE membership_function_defined
        REQUIRE membership_values_in_[0,1]

    CHECK coverage_if_required
    CHECK ordering_if_declared
    CHECK units_if_applicable

    RETURN validation_result
}

APPLICATION_RELATIONSHIPS {
    LinguisticVariable --supports--> FuzzyControl
    LinguisticVariable --supports--> ExpertSystems
    LinguisticVariable --supports--> ApproximateReasoning
    LinguisticVariable --supports--> DecisionSupport
    LinguisticVariable --supports--> Classification
    LinguisticVariable --supports--> HumanReadableRules
    LinguisticVariable --supports--> ArtificialIntelligence
    LinguisticVariable --supports--> KnowledgeRepresentation
}

ONTOLOGY_LINKS {
    PARENT := FuzzyLogicOntology

    RELATED := {
        FuzzyLogicOntology,
        FuzzySetOntology,
        MembershipFunctionOntology,
        DegreeOfTruthOntology,
        FuzzyRuleOntology,
        FuzzyInferenceOntology,
        LinguisticHedgeOntology,
        Type2FuzzySetOntology,
        ApproximateReasoningOntology
    }
}

SEMANTIC_EQUIVALENCE {
    LinguisticVariable ≈ FuzzyLinguisticVariable
    LinguisticTerm ≈ LinguisticValue
        WHEN represented_by_fuzzy_set

    "V IS A"
        ≈
    fuzzy_proposition(V,A)

    DegreeOfApplicability(A,x)
        ≈
    μ_A(x)
}

CONSTRAINTS {
    C1 :=
        every linguistic variable MUST have a declared universe of discourse

    C2 :=
        every linguistic term MUST have fuzzy semantics or an equivalent declared interpretation

    C3 :=
        membership values MUST remain within [0,1] for standard Type-1 terms

    C4 :=
        linguistic labels MUST be scoped to their variable and context

    C5 :=
        hedges MUST declare their semantic transformation

    C6 :=
        term ordering MUST NOT be assumed for nominal linguistic variables

    C7 :=
        physical units MUST be declared and transformed consistently where applicable

    C8 :=
        overlapping terms MUST NOT automatically be treated as contradictory

    C9 :=
        Type-1 and Type-2 linguistic terms MUST remain distinct

    C10 :=
        data-driven term generation MUST preserve interpretable label semantics when labels are assigned

    C11 :=
        linguistic approximation MUST identify its comparison criterion

    C12 :=
        transformations MUST preserve the intended meaning of terms and universe
}

REASONING_CHAIN Query Q {
    IDENTIFY linguistic_variable
    IDENTIFY universe_of_discourse
    IDENTIFY units_if_applicable
    IDENTIFY linguistic_terms
    IDENTIFY membership_functions

    IF crisp_value_provided
        THEN FUZZIFICATION

    IF fuzzy_proposition_requested
        THEN evaluate membership_degree

    IF hedge_present
        THEN apply declared hedge_semantics

    IF rule_context
        THEN map terms into antecedent_or_consequent semantics

    IF coverage_requested
        THEN identify uncovered_regions

    IF overlap_requested
        THEN compute overlap under declared measure

    IF ordering_requested
        THEN validate ordinal_semantics

    IF calibration_requested
        THEN identify expert_or_data_objective

    IF linguistic_approximation_requested
        THEN apply declared similarity_or_distance

    IF Type2_context
        THEN identify interval_or_secondary_membership

    VALIDATE_LINGUISTIC_VARIABLE
    RETURN result WITH derivation
}

CONFIDENCE {
    CORE_LINGUISTIC_VARIABLE_DEFINITION := 1.00
    TERM_AS_FUZZY_SET := 1.00
    FUZZIFICATION_MAPPING := 1.00
    STANDARD_HEDGE_EXAMPLES := 0.99
    RULE_RELATIONSHIP := 1.00

    NUMERICAL_RESULT :=
        IF membership_functions_and_parameters_complete THEN 1.00
        ELSE REQUIRE missing_information
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        LinguisticVariableConcept,
        TermSet,
        UniverseOfDiscourse,
        FuzzySemanticMapping
    }

    EXTENSIBLE := {
        LinguisticTerms,
        MembershipFunctionFamilies,
        HedgeSemantics,
        Partitions,
        GranularityLevels,
        Type2Terms,
        CalibrationMethods,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY variable_context
        VALIDATE universe
        VALIDATE term_semantics
        VALIDATE membership_range
        CHECK units
        CHECK term_ordering
        CHECK semantic_consistency
        ADD relationship IF non_contradictory
        UPDATE confidence
    }
}

AI_CONSUMPTION {
    MACHINE_READABLE := TRUE
    HUMAN_INTERPRETABLE := TRUE
    RECURSIVE_REASONING := TRUE
    ENTITY_RESOLUTION := TRUE
    TERM_RESOLUTION := TRUE
    SYMBOL_RESOLUTION := TRUE
    RELATIONSHIP_TRAVERSAL := TRUE
    FUZZIFICATION_REASONING := TRUE
    LINGUISTIC_HEDGE_REASONING := TRUE
    TERM_OVERLAP_REASONING := TRUE
    PARTITION_REASONING := TRUE
    RULE_MAPPING := TRUE
    TYPE2_REASONING := TRUE
    INTERPRETABILITY_VALIDATION := TRUE
}

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

OUTPUT {
    PRIMARY_ENTITY := LinguisticVariable
    INTERPRETATION :=
        "A linguistic variable represents a domain quantity through human-readable terms such as low, medium or high, with each term grounded by a fuzzy set over a declared universe of discourse. Membership functions convert crisp values into graded linguistic meanings, while hedges, partitions and fuzzy rules allow those meanings to participate in interpretable approximate reasoning."
}

END_FLOW