Predicate Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE → ONTOLOGIES → MATHEMATICAL ONTOLOGIES → MATHEMATICAL LOGIC ONTOLOGIES
PREDICATE LOGIC → PREDICATE ONTOLOGY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/predicate-ontology.html

FLOW_ALGEBRA PredicateOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN PredicateOntology := {
    Predicate,
    PredicateLogic,
    PredicateSymbol,
    Property,
    Relation,
    Individual,
    Object,
    Argument,
    ArgumentPosition,
    Arity,
    UnaryPredicate,
    BinaryPredicate,
    TernaryPredicate,
    NAryPredicate,
    Term,
    Variable,
    Constant,
    FunctionTerm,
    AtomicFormula,
    Formula,
    Proposition,
    Extension,
    Intension,
    DomainOfDiscourse,
    Interpretation,
    Model,
    Assignment,
    TruthValue,
    Satisfaction,
    Quantifier,
    UniversalQuantifier,
    ExistentialQuantifier
}

DEFINE ENTITY_TYPES := {
    PREDICATE,
    SYMBOL,
    PROPERTY,
    RELATION,
    INDIVIDUAL,
    ARGUMENT,
    TERM,
    FORMULA,
    INTERPRETATION,
    MODEL,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    HAS_ARGUMENT,
    HAS_ARGUMENT_POSITION,
    HAS_ARITY,
    APPLIES_TO,
    PREDICATES_OF,
    REPRESENTS,
    DENOTES,
    EXPRESSES,
    FORMS,
    OCCURS_IN,
    INTERPRETED_AS,
    HAS_EXTENSION,
    HAS_INTENSION,
    EVALUATES_TO,
    SATISFIED_BY,
    CONSTRAINS,
    RELATES,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Predicate.type = PREDICATE
SET Predicate.role = "express a property of, or relation among, one or more entities"
SET Predicate.context = PredicateLogic

RULE unary_predicate:
    Predicate(P)
    ∧ HAS_ARITY(P,1)
    -> UnaryPredicate(P)

RULE binary_predicate:
    Predicate(P)
    ∧ HAS_ARITY(P,2)
    -> BinaryPredicate(P)

RULE ternary_predicate:
    Predicate(P)
    ∧ HAS_ARITY(P,3)
    -> TernaryPredicate(P)

RULE n_ary_predicate:
    Predicate(P)
    ∧ HAS_ARITY(P,n)
    ∧ n >= 1
    -> NAryPredicate(P,n)

RULE predicate_application:
    Predicate(P)
    ∧ HAS_ARITY(P,n)
    ∧ Terms(t1...tn)
    -> AtomicFormula(P(t1,...,tn))

RULE unary_property_expression:
    UnaryPredicate(P)
    ∧ Term(x)
    -> AtomicFormula(P(x))
    ∧ PREDICATES_OF(P,x)

RULE relational_expression:
    Predicate(R)
    ∧ HAS_ARITY(R,n)
    ∧ n > 1
    ∧ Terms(t1...tn)
    -> AtomicFormula(R(t1,...,tn))
    ∧ RELATES(R,t1...tn)

RULE interpretation_of_predicate:
    Interpretation(I)
    ∧ Predicate(P)
    ∧ HAS_ARITY(P,n)
    ∧ DomainOfDiscourse(D)
    -> INTERPRETED_AS(I,P,Subset(D^n))

RULE predicate_extension:
    Interpretation(I)
    ∧ Predicate(P)
    -> HAS_EXTENSION(P, {
        tuple ∈ D^n | P(tuple) evaluates TRUE under I
    })

RULE atomic_truth:
    AtomicFormula(P(t1,...,tn))
    ∧ Interpretation(I)
    ∧ Denotations(t1...tn) ∈ Extension_I(P)
    -> EVALUATES_TO(P(t1,...,tn),TRUE)

RULE atomic_falsehood:
    AtomicFormula(P(t1,...,tn))
    ∧ Interpretation(I)
    ∧ Denotations(t1...tn) ∉ Extension_I(P)
    -> EVALUATES_TO(P(t1,...,tn),FALSE)

RULE quantified_predicate:
    Predicate(P)
    ∧ Variable(x)
    -> Formula(∀x P(x))
    OR Formula(∃x P(x))

RULE predicate_negation:
    AtomicFormula(P(args))
    -> Formula(¬P(args))

RULE predicate_conjunction:
    AtomicFormula(P(args))
    ∧ AtomicFormula(Q(args2))
    -> Formula(P(args) ∧ Q(args2))

RULE predicate_implication:
    AtomicFormula(P(x))
    ∧ AtomicFormula(Q(x))
    -> Formula(P(x) → Q(x))

DEFINE ARITY_MODEL := {
    arity_1: "property of one entity",
    arity_2: "relation between two entities",
    arity_3: "relation among three entities",
    arity_n: "relation among n entities"
}

DEFINE SYNTACTIC_FORM :=
    PredicateSymbol "(" ArgumentList ")"

DEFINE ARGUMENT_CONSTRAINT :=
    COUNT(ArgumentList) = Arity(Predicate)

DEFINE SEMANTIC_PIPELINE :=
    PredicateConcept
    -> PredicateSymbol
    -> DetermineArity
    -> BindArgumentPositions
    -> SupplyTerms
    -> ConstructAtomicFormula
    -> ApplyInterpretation
    -> ResolveArgumentDenotations
    -> TestMembershipInPredicateExtension
    -> AssignTruthValue

DEFINE REASONING_PIPELINE :=
    NaturalLanguageExpression
    -> IdentifyPropertyOrRelation
    -> IdentifyParticipants
    -> DeterminePredicateArity
    -> MapParticipantsToArguments
    -> ConstructPredicateExpression
    -> ValidateArgumentCount
    -> EmbedInFormula
    -> ApplyQuantificationWhereRequired
    -> Interpret
    -> Evaluate

DEFINE EXAMPLE_UNARY := {
    natural_language: "Socrates is human.",
    predicate: Human,
    arity: 1,
    argument: Socrates,
    formalisation: "Human(Socrates)"
}

DEFINE EXAMPLE_BINARY := {
    natural_language: "Alice loves Bob.",
    predicate: Loves,
    arity: 2,
    arguments: {Alice, Bob},
    formalisation: "Loves(Alice,Bob)"
}

DEFINE EXAMPLE_TERNARY := {
    natural_language: "Alice gives the book to Bob.",
    predicate: Gives,
    arity: 3,
    arguments: {Alice, Book, Bob},
    formalisation: "Gives(Alice,Book,Bob)"
}

DEFINE PREDICATE_DISTINCTIONS := {
    PredicateSymbol != PredicateExtension,
    Predicate != Individual,
    Predicate != Argument,
    PredicateApplication -> AtomicFormula,
    UnaryPredicate -> PropertyExpression,
    MultiArgumentPredicate -> RelationExpression
}

DEFINE ONTOLOGY_RELATIONS := {
    Predicate IS_COMPONENT_OF PredicateLogic,
    PredicateSymbol REPRESENTS Predicate,
    Predicate HAS_ARITY Arity,
    Predicate HAS_ARGUMENT Argument,
    Predicate FORMS AtomicFormula,
    UnaryPredicate IS_SUBTYPE_OF Predicate,
    BinaryPredicate IS_SUBTYPE_OF Predicate,
    TernaryPredicate IS_SUBTYPE_OF Predicate,
    NAryPredicate IS_SUBTYPE_OF Predicate,
    Interpretation INTERPRETS Predicate,
    Predicate HAS_EXTENSION Extension,
    AtomicFormula DEPENDS_ON Predicate,
    AtomicFormula DEPENDS_ON Term
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "predicate" <=> Predicate,
    "property predicate" <=> UnaryPredicate,
    "one-place predicate" <=> UnaryPredicate,
    "two-place predicate" <=> BinaryPredicate,
    "binary relation" <=> BinaryPredicate WHEN relational_use=TRUE,
    "three-place predicate" <=> TernaryPredicate,
    "n-place predicate" <=> NAryPredicate
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of predicates in formal logic",
    preserve_arity: TRUE,
    preserve_argument_order: TRUE,
    distinguish_symbol_from_extension: TRUE,
    distinguish_predicate_from_application: TRUE,
    allow_n_ary_relations: TRUE,
    support_quantified_embedding: TRUE,
    semantic_evaluation: model_theoretic,
    reasoning_mode: "symbolic + relational"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    predicate_classification: 0.99,
    arity_resolution: 0.99,
    formal_symbolic_mapping: 0.99,
    semantic_interpretation: 0.98,
    natural_language_predicate_extraction: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        predicate_arity,
        ordered_arguments,
        predicate_application,
        atomic_formula_construction,
        interpretation_extension_relation
    },
    extensible_layers: {
        typed_predicates,
        many_sorted_predicates,
        higher_order_predicates,
        computational_predicates,
        probabilistic_predicates,
        temporal_predicates,
        modal_predicates
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + ARITY_MODEL
    + SEMANTIC_PIPELINE
    + REASONING_PIPELINE
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: PredicateOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/predicate-logic/predicate-ontology.html",
    parent_domain: PredicateLogic,
    semantic_domain: MathematicalLogic,
    primary_entity: Predicate,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    flow_complete: TRUE
}

END_FLOW