Degree of Truth Ontology

FLOW_ALGEBRA DegreeOfTruthOntology v1.0

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

BEGIN_FLOW

ENTITY DegreeOfTruth {
    TYPE := GradedTruthValue
    DOMAIN := [0,1]
    DEFINITION := "A numerical value representing the extent to which a proposition is true within a fuzzy or graded logical semantics."
}

ENTITY FuzzyTruthValue {
    TYPE := DegreeOfTruth
}

ENTITY Proposition {
    TYPE := LogicalExpression
}

RELATIONSHIP Proposition --has_under_fuzzy_semantics--> DegreeOfTruth
RELATIONSHIP DegreeOfTruth --used_by--> FuzzyLogic
RELATIONSHIP DegreeOfTruth --may_be_derived_from--> MembershipFunction
RELATIONSHIP DegreeOfTruth --generalises--> BooleanTruthValue

TRUTH_DOMAIN {
    FALSE := 0
    TRUE := 1
    PARTIAL_TRUTH := t WHERE 0<t<1
}

BOOLEAN_BOUNDARY {
    IF t∈{0,1}
    THEN
        t corresponds_to BooleanFalseOrTrue
        under compatible semantics
}

FUZZY_PROPOSITION {
    FORM := "x IS A"

    TRUTH_DEGREE :=
        Truth(x IS A) := μ_A(x)
}

EVALUATION_FUNCTION {
    v:FuzzyFormula->[0,1]
}

ATOMIC_EVALUATION {
    v(p) := assigned_degree_in_[0,1]
}

STANDARD_NEGATION {
    v(¬P) := 1-v(P)
}

FUZZY_CONJUNCTION {
    v(P∧Q) :=
        T(v(P),v(Q))

    REQUIRE selected_t_norm T
}

FUZZY_DISJUNCTION {
    v(P∨Q) :=
        S(v(P),v(Q))

    REQUIRE selected_t_conorm S
}

MIN_MAX_SEMANTICS {
    v(P∧Q) := min(v(P),v(Q))
    v(P∨Q) := max(v(P),v(Q))
    v(¬P) := 1-v(P)
}

PRODUCT_CONJUNCTION {
    v(P∧Q) :=
        v(P)*v(Q)
}

LUKASIEWICZ_CONJUNCTION {
    v(P∧Q) :=
        max(0,v(P)+v(Q)-1)
}

LUKASIEWICZ_DISJUNCTION {
    v(P∨Q) :=
        min(1,v(P)+v(Q))
}

ENTITY FuzzyImplication {
    TYPE := BinaryTruthFunction
    SIGNATURE := [0,1]^2->[0,1]
}

LUKASIEWICZ_IMPLICATION {
    v(P->Q) :=
        min(1,1-v(P)+v(Q))
}

GODEL_IMPLICATION {
    v(P->Q) :=
        IF v(P)<=v(Q)
        THEN 1
        ELSE v(Q)
}

REICHENBACH_IMPLICATION {
    v(P->Q) :=
        1-v(P)+v(P)*v(Q)
}

RESIDUATED_IMPLICATION {
    GIVEN t_norm T

    I_T(a,b) :=
        sup{c∈[0,1] | T(a,c)<=b}
}

TRUTH_FUNCTION_COMPOSITION {
    GIVEN formula F
    AND atomic degrees

    PARSE F
    APPLY selected fuzzy operators recursively
    RETURN v(F)
}

DEGREE_ORDERING {
    FOR a,b∈[0,1]:

    a<b :=
        a represents a lower truth degree than b
        within the same declared truth semantics
}

MAXIMAL_TRUTH {
    v(P)=1
    := fully_true_under_selected_semantics
}

MINIMAL_TRUTH {
    v(P)=0
    := fully_false_under_selected_semantics
}

INTERMEDIATE_TRUTH {
    0<v(P)<1
    := partially_true_under_selected_semantics
}

SEMANTIC_DISTINCTIONS {
    DegreeOfTruth != Probability
    DegreeOfTruth != Confidence
    DegreeOfTruth != Frequency
    DegreeOfTruth != BeliefDegree
        UNLESS explicitly defined by specialised semantics
}

TRUTH_VS_PROBABILITY {
    FUZZY_TRUTH :=
        extent_to_which_predicate_applies_or_statement_is_true

    PROBABILITY :=
        uncertainty_about_event_or_proposition

    EXAMPLE_STRUCTURE :=
        "A person may have truth degree 0.8 for 'tall' without implying an 80% probability that the person is tall."
}

TRUTH_VS_MEMBERSHIP {
    FOR proposition "x IS A":
        DegreeOfTruth
        ≈
        MembershipDegree μ_A(x)

    FOR arbitrary fuzzy formula:
        DegreeOfTruth may be recursively derived from multiple atomic membership degrees
}

TRUTH_VS_BOOLEAN {
    BooleanLogic :=
        truth_domain {0,1}

    FuzzyLogic :=
        commonly truth_domain [0,1]
}

TRUTH_THRESHOLD {
    GIVEN threshold θ∈[0,1]

    CRISP_DECISION(P) :=
        TRUE IF v(P)>=θ
        ELSE FALSE

    WARNING :=
        thresholding creates a derived crisp decision and does not erase original graded truth
}

ALPHA_LEVEL_RELATIONSHIP {
    IF v(x IS A)>=alpha
    THEN
        x∈A_alpha

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

LINGUISTIC_PREDICATE {
    EXAMPLE :=
        "Temperature is hot"

    TRUTH_DEGREE :=
        μ_Hot(temperature)
}

FUZZIFICATION_RELATIONSHIP {
    CrispInput
        -> MembershipFunction
        -> MembershipDegree
        -> AtomicDegreeOfTruth
}

RULE_ANTECEDENT_TRUTH {
    IF antecedent :=
        P AND Q

    THEN firing_strength :=
        T(v(P),v(Q))
        under selected fuzzy inference semantics
}

RULE_DISJUNCTIVE_TRUTH {
    IF antecedent :=
        P OR Q

    THEN degree :=
        S(v(P),v(Q))
}

RULE_NEGATION_TRUTH {
    IF antecedent :=
        NOT P

    THEN degree :=
        N(v(P))
}

FUZZY_RULE {
    FORM :=
        IF P THEN Q

    TRUTH_OR_FIRING_SEMANTICS :=
        depends_on selected fuzzy implication/inference architecture
}

MAMDANI_RELATIONSHIP {
    antecedent_degree
        --determines-->
        rule_firing_strength

    firing_strength
        --modifies-->
        output_fuzzy_set
}

SUGENO_RELATIONSHIP {
    antecedent_degree
        --determines-->
        rule_weight
}

TRUTH_AGGREGATION {
    MULTIPLE_RULES
        -> compute individual firing strengths
        -> aggregate according to inference system
}

NORMALISED_TRUTH_DOMAIN {
    STANDARD := [0,1]

    NOTE :=
        other many-valued logics may use different truth structures;
        this ontology uses the standard fuzzy [0,1] domain unless declared otherwise
}

CONTINUUM_PROPERTY {
    BETWEEN 0 AND 1:
        infinitely many real-valued truth degrees exist
}

ORDERED_TRUTH_STRUCTURE {
    [0,1]
        equipped_with
        natural_real_order
}

LATTICE_RELATIONSHIP {
    UNDER min/max semantics:

    meet(a,b) := min(a,b)
    join(a,b) := max(a,b)
}

COMPLEMENT_RELATIONSHIP {
    UNDER standard_negation:
        complement(a) := 1-a
}

FIXED_POINT_OF_STANDARD_NEGATION {
    N(0.5)=0.5
}

DOUBLE_NEGATION {
    N(N(a))=a
    FOR standard_negation N(a)=1-a
}

DE_MORGAN_MIN_MAX {
    N(min(a,b))
        =
    max(N(a),N(b))

    N(max(a,b))
        =
    min(N(a),N(b))
}

IDEMPOTENCE_MIN_MAX {
    min(a,a)=a
    max(a,a)=a
}

NON_IDEMPOTENT_PRODUCT_WARNING {
    a*a != a
    FOR general a∈(0,1)

    CONSEQUENCE :=
        product t-norm does not satisfy idempotence except boundary values
}

OPERATOR_DEPENDENCE {
    SAME atomic degrees
        + DIFFERENT fuzzy operators
        -> MAY produce different compound truth degrees

    REQUIRE :=
        operator family MUST be declared
}

TRUTH_PRESERVATION {
    A transformation F -> G IS truth_preserving
    IFF
        v(F)=v(G)
        FOR all valuations under selected fuzzy semantics
}

FUZZY_TAUTOLOGY {
    STRONG_FORM :=
        v(F)=1
        FOR_ALL valuations

    REQUIRE :=
        selected fuzzy logic and operator semantics
}

FUZZY_CONTRADICTION {
    STRONG_FORM :=
        v(F)=0
        FOR_ALL valuations

    REQUIRE :=
        selected fuzzy logic
}

FUZZY_ENTAILMENT {
    REQUIRE :=
        explicit definition of semantic consequence

    NOTE :=
        multiple graded entailment notions exist
}

DEGREE_OF_SATISFACTION {
    MAY_EQUAL :=
        v(F)
        WHEN formula expresses a constraint or requirement
        under explicitly selected fuzzy semantics
}

FUZZY_CONSTRAINT {
    Formula F
        -> DegreeOfTruth
        -> DegreeOfConstraintSatisfaction
        WHEN declared by application semantics
}

MULTI_CRITERIA_AGGREGATION {
    Degrees d1,...,dn
        -> AggregationOperator
        -> CombinedDegree

    REQUIRE :=
        aggregation operator explicitly declared
}

WEIGHTED_DEGREE {
    GIVEN weights w_i

    weighted_aggregation :=
        selected weighted fuzzy operator

    WARNING :=
        weighted arithmetic average is not automatically a fuzzy logical conjunction/disjunction
}

TYPE_2_RELATIONSHIP {
    Type1DegreeOfTruth :=
        single value in [0,1]

    Type2Representation :=
        uncertainty about membership/truth degree may itself be represented fuzzily
}

INTERVAL_VALUED_FUZZY_TRUTH {
    TRUTH_VALUE :=
        [lower,upper] subseteq [0,1]

    REQUIRE :=
        interval-valued fuzzy semantics
}

APPLICATION_RELATIONSHIPS {
    DegreeOfTruth --supports--> FuzzyInference
    DegreeOfTruth --supports--> ApproximateReasoning
    DegreeOfTruth --supports--> FuzzyControl
    DegreeOfTruth --supports--> Classification
    DegreeOfTruth --supports--> DecisionSupport
    DegreeOfTruth --supports--> ConstraintSatisfaction
    DegreeOfTruth --supports--> ArtificialIntelligence
    DegreeOfTruth --supports--> LinguisticReasoning
}

ONTOLOGY_LINKS {
    PARENT := FuzzyLogicOntology

    RELATED := {
        FuzzySetOntology,
        MembershipFunctionOntology,
        FuzzyLogicOntology,
        TNormOntology,
        TConormOntology,
        FuzzyImplicationOntology,
        ManyValuedLogicOntology,
        BooleanLogicOntology,
        ProbabilityOntology,
        ApproximateReasoningOntology
    }
}

SEMANTIC_EQUIVALENCE {
    DegreeOfTruth ≈ FuzzyTruthDegree
    DegreeOfTruth ≈ GradedTruthValue

    DegreeOfTruth(x IS A)
        ≈
    MembershipDegree μ_A(x)

    FullTruth ≈ 1
    FullFalsehood ≈ 0
}

CONSTRAINTS {
    C1 :=
        standard fuzzy truth degrees MUST remain within [0,1]

    C2 :=
        degree of truth MUST NOT automatically be interpreted as probability

    C3 :=
        degree of truth MUST NOT automatically be interpreted as confidence or belief

    C4 :=
        compound truth evaluation MUST identify selected fuzzy operators

    C5 :=
        implication semantics MUST be declared when evaluating fuzzy implication

    C6 :=
        truth thresholds MUST be treated as derived crisp decisions rather than original fuzzy truth

    C7 :=
        Boolean identities MUST NOT be transferred to arbitrary fuzzy operators unless valid

    C8 :=
        fuzzy tautology and entailment claims MUST identify the fuzzy logic semantics

    C9 :=
        Type-1, interval-valued and Type-2 truth representations MUST remain distinct

    C10 :=
        transformations MUST preserve the selected graded truth semantics
}

REASONING_CHAIN Query Q {
    IDENTIFY proposition_or_formula
    IDENTIFY atomic_truth_degrees
    IDENTIFY fuzzy_logic_variant
    IDENTIFY truth_domain
    IDENTIFY operator_family

    IF atomic_predicate_of_form_x_IS_A
        THEN derive degree from membership_function

    IF compound_formula {
        PARSE formula
        APPLY selected_negation
        APPLY selected_t_norm
        APPLY selected_t_conorm
        APPLY selected_implication
    }

    IF threshold_requested
        THEN derive crisp_decision_without_discarding_original_degree

    IF comparison_requested
        THEN compare degrees under same semantics

    IF probability_comparison
        THEN enforce semantic_distinction

    IF rule_antecedent_context
        THEN compute firing_strength

    IF Type2_or_interval_context
        THEN identify extended_truth_representation

    VALIDATE degree_range
    VALIDATE operator_assumptions
    RETURN truth_degree WITH derivation
}

CONFIDENCE {
    CORE_DEGREE_OF_TRUTH_DEFINITION := 1.00
    STANDARD_DOMAIN_0_1 := 1.00
    MEMBERSHIP_TRUTH_RELATIONSHIP := 1.00
    STANDARD_NEGATION := 1.00
    OPERATOR_DEPENDENCE := 1.00

    COMPUTED_TRUTH_DEGREE :=
        IF all_atomic_degrees_and_operators_known THEN 1.00
        ELSE REQUIRE missing_information
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        GradedTruthConcept,
        StandardTruthDomain,
        BoundaryTruthValues,
        SemanticDistinctionFromProbability
    }

    EXTENSIBLE := {
        FuzzyOperatorFamilies,
        ImplicationOperators,
        GradedEntailment,
        IntervalTruth,
        Type2Truth,
        ApplicationInterpretations,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY fuzzy_semantics
        VALIDATE truth_domain
        VALIDATE operator_family
        CHECK truth_interpretation
        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
    MEMBERSHIP_TO_TRUTH_MAPPING := TRUE
    FUZZY_OPERATOR_REASONING := TRUE
    RULE_STRENGTH_REASONING := TRUE
    THRESHOLD_REASONING := TRUE
    SEMANTIC_DISTINCTION_VALIDATION := TRUE
    VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
    PRIMARY_ENTITY := DegreeOfTruth

    INTERPRETATION :=
        "A degree of truth is a graded logical value, commonly in [0,1], representing how strongly a proposition is true under fuzzy semantics. Atomic degrees may arise from fuzzy-set membership, while compound degrees are computed using explicitly selected fuzzy operators. These values describe graded truth and must remain distinct from probability, confidence and frequency unless a specialised semantics explicitly relates them."
}

END_FLOW