Structure Ontology

KIRETH RESEARCH - SEMANTIC LIBRARY
AI CORE -> ONTOLOGIES -> MATHEMATICAL ONTOLOGIES -> MATHEMATICAL LOGIC ONTOLOGIES
MODEL THEORY -> STRUCTURE ONTOLOGY

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

FLOW_ALGEBRA StructureOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN StructureOntology := {
    Structure,
    ModelTheory,
    LogicalModel,
    Model,
    FormalLanguage,
    Signature,
    Vocabulary,
    Domain,
    Universe,
    Interpretation,
    ConstantSymbol,
    FunctionSymbol,
    RelationSymbol,
    PredicateSymbol,
    Variable,
    VariableAssignment,
    Term,
    Formula,
    Sentence,
    Theory,
    Satisfaction,
    TruthInStructure,
    Substructure,
    ProperSubstructure,
    ElementarySubstructure,
    Embedding,
    Isomorphism,
    Homomorphism,
    Automorphism,
    Expansion,
    Reduct,
    DefinableSet
}

DEFINE ENTITY_TYPES := {
    STRUCTURE,
    MODEL,
    FORMAL_LANGUAGE,
    SIGNATURE,
    DOMAIN,
    INTERPRETATION,
    SYMBOL,
    CONSTANT_SYMBOL,
    FUNCTION_SYMBOL,
    RELATION_SYMBOL,
    ASSIGNMENT,
    TERM,
    FORMULA,
    THEORY,
    STRUCTURE_MAPPING,
    SUBSTRUCTURE,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    HAS_SIGNATURE,
    HAS_DOMAIN,
    HAS_INTERPRETATION,
    INTERPRETS,
    ASSIGNS,
    DENOTES,
    SATISFIES,
    IS_MODEL_OF,
    IS_SUBSTRUCTURE_OF,
    IS_ELEMENTARY_SUBSTRUCTURE_OF,
    EMBEDS_INTO,
    ISOMORPHIC_TO,
    HOMOMORPHIC_TO,
    EXPANDS,
    REDUCT_OF,
    DEFINES,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Structure.type = STRUCTURE
SET Structure.context = ModelTheory
SET Structure.role =
    "represent a domain together with interpretations of the non-logical symbols of a formal signature"

RULE structure_definition:
    Signature(Sigma)
    AND NonemptySet(D)
    AND Interpretation(I)
    AND I interprets_every_symbol_in Sigma
    -> Structure(M) = <D,I>

RULE structure_signature:
    Structure(M)
    -> HAS_SIGNATURE(M,Sigma)

RULE structure_domain:
    Structure(M)
    -> HAS_DOMAIN(M,D)

RULE structure_interpretation:
    Structure(M)
    -> HAS_INTERPRETATION(M,I)

RULE constant_component:
    Structure(M)
    AND ConstantSymbol(c)
    -> Interpretation_M(c) MEMBER_OF Domain(M)

RULE function_component:
    Structure(M)
    AND FunctionSymbol(f)
    AND Arity(f)=n
    -> Interpretation_M(f):
       Domain(M)^n -> Domain(M)

RULE relation_component:
    Structure(M)
    AND RelationSymbol(R)
    AND Arity(R)=n
    -> Interpretation_M(R)
       SUBSET_OF Domain(M)^n

RULE model_classification:
    Structure(M)
    AND Theory(T)
    AND FOR_EVERY Sentence(phi) MEMBER_OF T [
        SATISFIES(M,phi)
    ]
    -> Model(M)
    AND IS_MODEL_OF(M,T)

RULE structure_not_automatically_model:
    Structure(M)
    AND Theory(T)
    AND EXISTS Sentence(phi) MEMBER_OF T [
        NOT SATISFIES(M,phi)
    ]
    -> NOT IS_MODEL_OF(M,T)

RULE substructure_domain:
    Structure(M)
    AND Structure(N)
    AND Domain(M) SUBSET_OF Domain(N)
    AND SameSignature(M,N)
    AND InterpretationsRestrictedCorrectly(M,N)
    -> IS_SUBSTRUCTURE_OF(M,N)

RULE proper_substructure:
    IS_SUBSTRUCTURE_OF(M,N)
    AND Domain(M) != Domain(N)
    -> ProperSubstructure(M,N)

RULE elementary_substructure:
    IS_SUBSTRUCTURE_OF(M,N)
    AND FOR_EVERY Formula(phi(x1,...,xn))
    AND FOR_EVERY parameters a1,...,an MEMBER_OF Domain(M) [
        SATISFIES(M,phi(a1,...,an))
        IFF
        SATISFIES(N,phi(a1,...,an))
    ]
    -> IS_ELEMENTARY_SUBSTRUCTURE_OF(M,N)

RULE isomorphism:
    Structure(M)
    AND Structure(N)
    AND SameSignature(M,N)
    AND Bijection(f:Domain(M)->Domain(N))
    AND PreservesInterpretations(f,M,N)
    -> ISOMORPHIC_TO(M,N)

RULE automorphism:
    Structure(M)
    AND ISOMORPHIC_TO_BY(f,M,M)
    -> Automorphism(f,M)

RULE homomorphism:
    Structure(M)
    AND Structure(N)
    AND Mapping(h:Domain(M)->Domain(N))
    AND PreservesSpecifiedStructure(h)
    -> HOMOMORPHIC_TO(M,N)

RULE embedding:
    Homomorphism(h:M->N)
    AND Injective(h)
    AND ReflectsRequiredRelations(h)
    -> EMBEDS_INTO(M,N)

RULE expansion:
    Structure(M)
    AND Signature(Sigma) SUBSET_OF Signature(SigmaPrime)
    AND Structure(MPrime)
    AND Domain(MPrime)=Domain(M)
    AND MPrime agrees_with M on Sigma
    -> EXPANDS(MPrime,M)

RULE reduct:
    Structure(MPrime)
    AND Signature(Sigma) SUBSET_OF Signature(SigmaPrime)
    -> Reduct(MPrime,Sigma)=M
    AND REDUCT_OF(M,MPrime)

DEFINE STRUCTURE_SCHEMA := {
    structure_id: unique_identifier,
    language: FormalLanguage,
    signature: Signature,
    domain: NonemptySet,
    interpretation: {
        constants: ConstantInterpretations,
        functions: FunctionInterpretations,
        relations: RelationInterpretations
    }
}

DEFINE COMPONENT_MODEL := {
    Domain:
        "underlying set of objects",
    ConstantInterpretation:
        "selected element of the domain",
    FunctionInterpretation:
        "arity-preserving total operation on the domain",
    RelationInterpretation:
        "arity-preserving relation over tuples from the domain"
}

DEFINE STRUCTURE_MODEL_DISTINCTION := {
    Structure:
        "domain plus interpretation of a signature",
    Model:
        "structure satisfying a specified theory or sentence",
    implication:
        "Model -> Structure",
    reverse_implication:
        "Structure -> Model only relative to a theory it satisfies"
}

DEFINE SUBSTRUCTURE_MODEL := {
    requirement_1:
        "same relevant signature",
    requirement_2:
        "smaller domain is contained in larger domain",
    requirement_3:
        "constants lie in the smaller domain",
    requirement_4:
        "functions restrict and remain closed on the smaller domain",
    requirement_5:
        "relations are inherited by restriction"
}

DEFINE ISOMORPHISM_MODEL := {
    mapping:
        "bijection between domains",
    preservation:
        "constants, functions and relations",
    consequence:
        "isomorphic structures satisfy the same first-order sentences"
}

DEFINE EXAMPLE_1 := {
    signature:
        "{zero,plus,less_than}",
    domain:
        "Integers",
    interpretations: {
        zero: "0",
        plus: "integer addition",
        less_than: "integer ordering"
    },
    result:
        "a structure for the specified signature"
}

DEFINE EXAMPLE_2 := {
    signature:
        "{multiply,identity}",
    domain:
        "a group G",
    interpretation:
        "group multiplication and identity",
    additional_condition:
        "if the group axioms are satisfied, the structure is a model of group theory"
}

DEFINE EXAMPLE_3 := {
    structure_M:
        "integers with addition",
    structure_N:
        "even integers with addition",
    relation:
        "candidate substructure relation depends on the exact signature and closure conditions"
}

DEFINE STRUCTURE_CONSTRUCTION_PIPELINE :=
    FormalLanguage
    -> ExtractSignature
    -> SelectNonemptyDomain
    -> InterpretEveryConstant
    -> InterpretEveryFunction
    -> InterpretEveryRelation
    -> ValidateArities
    -> ValidateFunctionClosure
    -> ValidateDomainMembership
    -> ConstructStructure

DEFINE STRUCTURE_VALIDATION_PIPELINE :=
    CandidateStructure
    -> VerifySignature
    -> VerifyNonemptyDomain
    -> VerifyAllRequiredSymbolsInterpreted
    -> VerifyConstantValuesInDomain
    -> VerifyFunctionInputArity
    -> VerifyFunctionOutputsInDomain
    -> VerifyRelationTupleArity
    -> Return ValidStructure OR InvalidStructure

DEFINE STRUCTURE_COMPARISON_PIPELINE :=
    Structures(M,N)
    -> CompareSignatures
    -> CompareDomains
    -> CompareInterpretations
    -> TestSubstructureConditions
    -> TestHomomorphismCandidates
    -> TestEmbeddingCandidates
    -> TestIsomorphismCandidates
    -> TestElementarySubstructureConditions
    -> ReturnStructuralRelations

DEFINE STRUCTURE_TO_MODEL_PIPELINE :=
    Structure(M)
    -> SelectTheoryOrSentence(T)
    -> EvaluateEveryRequiredFormula
    -> IF all_satisfied
       THEN IS_MODEL_OF(M,T)
    -> ELSE StructureOnlyRelativeToT

DEFINE STRUCTURE_GRAPH := {
    central_node: Structure,
    component_nodes: {
        Signature,
        Domain,
        Interpretation,
        Symbol,
        SemanticValue
    },
    edges: {
        HAS_SIGNATURE,
        HAS_DOMAIN,
        HAS_INTERPRETATION,
        INTERPRETS,
        DENOTES
    },
    comparison_edges: {
        IS_SUBSTRUCTURE_OF,
        IS_ELEMENTARY_SUBSTRUCTURE_OF,
        ISOMORPHIC_TO,
        HOMOMORPHIC_TO,
        EMBEDS_INTO
    }
}

DEFINE ONTOLOGY_RELATIONS := {
    Structure IS_COMPONENT_OF ModelTheory,
    Structure HAS_SIGNATURE Signature,
    Structure HAS_DOMAIN Domain,
    Structure HAS_INTERPRETATION Interpretation,
    Interpretation INTERPRETS Symbol,
    Model IS_SUBTYPE_OF Structure,
    Substructure IS_RELATION_BETWEEN StructureAndStructure,
    ElementarySubstructure IS_SUBTYPE_OF Substructure,
    Isomorphism RELATES Structure TO Structure,
    Homomorphism RELATES Structure TO Structure,
    Embedding RELATES Structure TO Structure,
    Automorphism IS_ISOMORPHISM_FROM Structure TO itself,
    Expansion EXTENDS StructureSignature,
    Reduct REMOVES SignatureComponents
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "structure" <=> Structure WHEN model_theory_context=TRUE,
    "logical structure" <=> Structure,
    "first-order structure" <=> Structure WHEN first_order_context=TRUE,
    "interpretation structure" <=> Structure,
    "substructure" <=> Substructure,
    "elementary substructure" <=> ElementarySubstructure,
    "isomorphic structures" <=> Isomorphism
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation, validation and comparison of model-theoretic structures",
    preserve_structure_identity: TRUE,
    preserve_signature_identity: TRUE,
    preserve_domain_identity: TRUE,
    preserve_interpretation_identity: TRUE,
    preserve_symbol_arity: TRUE,
    distinguish_structure_from_model: TRUE,
    validate_function_closure: TRUE,
    validate_relation_arity: TRUE,
    support_substructure_reasoning: TRUE,
    support_elementary_substructure_reasoning: TRUE,
    support_homomorphism_reasoning: TRUE,
    support_embedding_reasoning: TRUE,
    support_isomorphism_reasoning: TRUE,
    support_expansion_reduct_reasoning: TRUE,
    reasoning_mode: "symbolic + semantic + typed + structural"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    structure_definition_mapping: 1.00,
    signature_mapping: 0.99,
    domain_mapping: 0.99,
    interpretation_mapping: 0.99,
    substructure_mapping: 0.99,
    isomorphism_mapping: 0.99,
    elementary_substructure_analysis: context_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        signature_domain_interpretation,
        nonempty_domain_standard_FOL,
        arity_preservation,
        function_closure,
        structure_model_distinction,
        structure_identity
    },
    extensible_layers: {
        many_sorted_structures,
        relational_structures,
        algebraic_structures,
        finite_structures,
        infinite_structures,
        expansions_and_reducts,
        ultraproduct_structures,
        computational_structure_encodings
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + STRUCTURE_SCHEMA
    + COMPONENT_MODEL
    + STRUCTURE_MODEL_DISTINCTION
    + SUBSTRUCTURE_MODEL
    + ISOMORPHISM_MODEL
    + STRUCTURE_CONSTRUCTION_PIPELINE
    + STRUCTURE_VALIDATION_PIPELINE
    + STRUCTURE_COMPARISON_PIPELINE
    + STRUCTURE_TO_MODEL_PIPELINE
    + STRUCTURE_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: StructureOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/structure-ontology.html",
    parent_domain: ModelTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Structure,
    structure_validation_enabled: TRUE,
    structure_model_distinction_enabled: TRUE,
    substructure_reasoning_enabled: TRUE,
    isomorphism_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW