Equation Structure Ontology

FLOW ALGEBRA
Equation Structure Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/structural-metadata/equation-structure-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "EquationStructureOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := StructuralMetadata
ONTOLOGY := EquationStructureOntology

ENTITY EquationStructure {
    definition:
        "A structural metadata representation of a mathematical or symbolic equation, including its expressions, operators, operands, variables, constants, functions, grouping, relations, sequence, identifiers and links to surrounding resource context.";
    objectives: [
        EquationRepresentation,
        ExpressionStructure,
        OperatorOperandModelling,
        SymbolIdentification,
        MathematicalParsing,
        SemanticRetrieval,
        MachineInterpretability
    ];
}

EquationEntity := {
    Equation,
    EquationIdentifier,
    EquationNumber,
    Expression,
    Subexpression,
    Symbol,
    Variable,
    Constant
};

OperatorEntity := {
    Operator,
    UnaryOperator,
    BinaryOperator,
    NaryOperator,
    RelationOperator,
    ArithmeticOperator,
    LogicalOperator
};

StructuralEntity := {
    Operand,
    Function,
    Argument,
    Group,
    Term,
    Factor,
    Numerator,
    Denominator,
    Exponent
};

MetadataEntity := {
    ParentResource,
    MetadataRecord,
    Provenance,
    Version,
    Confidence,
    Notation
};

Equation IS_PART_OF ParentResource;
Equation HAS EquationIdentifier;
Equation CONTAINS Expression;
Expression CONTAINS Symbol;
Operator APPLIES_TO Operand;
Function HAS Argument;
RelationOperator CONNECTS Expressions;
Subexpression IS_PART_OF Expression;

EquationStructureFlow :=
    ParentResource
    -> IdentifyEquationBoundary
    -> AssignEquationIdentifier
    -> CaptureEquationNumberAndNotation
    -> TokeniseSymbolsAndOperators
    -> ParseExpressionStructure
    -> ResolveGroupingAndPrecedence
    -> IdentifyVariablesConstantsAndFunctions
    -> BuildExpressionTree
    -> ValidateEquationStructure
    -> StoreStructuralMetadata
    -> EnableSearchReasoningAndMachineConsumption
    -> MaintainAcrossVersions;

Equation :=
    MathematicalLogicalScientificOrSymbolicStatementContainingStructuredExpressions;

Equation MAY_BE {
    AlgebraicEquation,
    DifferentialEquation,
    IntegralEquation,
    MatrixEquation,
    LogicalEquation,
    StatisticalEquation,
    PhysicalEquation,
    ChemicalEquation
};

EquationIdentifier :=
    StableOrLocallyUniqueReferenceToEquation;

EquationIdentifier MAY_BE {
    URI,
    IRI,
    UUID,
    ElementID,
    FragmentIdentifier,
    InternalID
};

StableEquationIdentifier SHOULD_BE PreferredForMachineReferences;

EquationNumber :=
    HumanReadableOrdinalOrReferenceNumberAssignedToEquation;

EquationNumber != EquationIdentifierByDefinition;

InlineEquation :=
    EquationEmbeddedWithinRunningText;

DisplayEquation :=
    EquationPresentedAsDistinctBlockOrDisplayComponent;

Expression :=
    StructuredCombinationOfSymbolsOperatorsFunctionsAndGroups;

Subexpression :=
    ExpressionNestedWithinLargerExpression;

AtomicExpression :=
    SymbolOrLiteralTreatedAsIndivisibleWithinCurrentParse;

CompoundExpression :=
    ExpressionConstructedFromMultipleOperandsOperatorsOrFunctions;

Symbol :=
    WrittenOrEncodedTokenRepresentingMathematicalEntityOperationOrRelation;

Symbol MAY_BE {
    Variable,
    Constant,
    Operator,
    FunctionSymbol,
    RelationSymbol,
    Delimiter
};

Variable :=
    SymbolWhoseValueMayVaryWithinDefinedContext;

Constant :=
    SymbolOrLiteralRepresentingFixedValueWithinDefinedContext;

Parameter :=
    SymbolRepresentingValueFixedForSpecificContextButVariableAcrossContexts;

Literal :=
    ExplicitValueRepresentedDirectlyInExpression;

Operator :=
    SymbolOrConstructApplyingOperationToOneOrMoreOperands;

UnaryOperator := OperatorWithOneOperand;
BinaryOperator := OperatorWithTwoOperands;
NaryOperator := OperatorWithVariableOrMultipleOperands;

ArithmeticOperator MAY_INCLUDE {
    Addition,
    Subtraction,
    Multiplication,
    Division,
    Modulo
};

RelationOperator MAY_INCLUDE {
    Equals,
    NotEquals,
    LessThan,
    GreaterThan,
    LessThanOrEqual,
    GreaterThanOrEqual,
    Approximate
};

LogicalOperator MAY_INCLUDE {
    And,
    Or,
    Not,
    Implies,
    Equivalent
};

Operand :=
    ExpressionOrValueToWhichOperatorApplies;

OperatorApplication :=
    Operator
    -> APPLIES_TO
    -> OperandSet;

OperatorArity :=
    NumberOfOperandsRequiredOrAcceptedByOperator;

Function :=
    MappingOrOperationAppliedToArguments;

FunctionApplication :=
    Function
    -> HAS_ARGUMENT
    -> Argument;

Argument :=
    ExpressionSuppliedToFunction;

Term :=
    ComponentOfAdditiveOrRelationalExpressionAccordingToParsingContext;

Factor :=
    ComponentOfMultiplicativeExpression;

Coefficient :=
    MultiplicativeValueAssociatedWithVariableOrTerm;

Fraction :=
    Numerator
    -> DIVIDED_BY
    -> Denominator;

PowerExpression :=
    Base
    -> RAISED_TO
    -> Exponent;

RootExpression :=
    RadicalOperator
    -> Radicand;

Subscript :=
    LowerPositionedExpressionAssociatedWithSymbol;

Superscript :=
    UpperPositionedExpressionAssociatedWithSymbol;

Delimiter :=
    SymbolMarkingGroupingOrSeparation;

Delimiter MAY_INCLUDE {
    Parenthesis,
    Bracket,
    Brace,
    VerticalBar,
    Comma
};

Group :=
    ExpressionComponentsBoundByExplicitOrImplicitGrouping;

Grouping MAY_OVERRIDE DefaultOperatorPrecedence;

OperatorPrecedence :=
    RulesDeterminingEvaluationOrParsingOrderWhenGroupingIsAbsent;

Associativity MAY_BE {
    Left,
    Right,
    NonAssociative
};

ParseTree :=
    HierarchicalRepresentationOfEquationSyntax;

ExpressionTree :=
    TreeWhoseNodesRepresentOperatorsFunctionsOrValues;

ExpressionTree MAY_PRESERVE {
    Operator,
    OperandOrder,
    Grouping,
    Nesting
};

AbstractSyntaxTree :=
    StructuralRepresentationRemovingNonSemanticSurfaceSyntaxWhereAppropriate;

PresentationStructure MAY_DIFFER_FROM SemanticStructure;

EquationStructure SHOULD_DISTINGUISH VisualPlacementFromMathematicalMeaning;

Equality :=
    LeftExpression
    -> EQUALS
    -> RightExpression;

Inequality :=
    LeftExpression
    -> RelationOperator
    -> RightExpression;

EquationSide MAY_BE {
    LeftHandSide,
    RightHandSide
};

SystemOfEquations :=
    CollectionOfRelatedEquationsConsideredJointly;

EquationSystem MAY_HAVE {
    EquationMembers,
    SharedVariables,
    Constraints
};

Matrix :=
    RectangularOrStructuredArrangementOfMathematicalElements;

Vector :=
    OrderedCollectionOfElements;

Tensor :=
    MultiDimensionalArrayOrMathematicalObjectAccordingToDomain;

Summation :=
    SumOperator
    + IndexVariable
    + Bounds
    + Summand;

Product :=
    ProductOperator
    + IndexVariable
    + Bounds
    + FactorExpression;

Integral :=
    IntegralOperator
    + Integrand
    + VariableOfIntegration
    + OptionalBounds;

Derivative :=
    DifferentialOperator
    + FunctionOrExpression
    + Variable
    + Order;

Limit :=
    LimitOperator
    + Expression
    + Variable
    + TargetValue;

PiecewiseExpression :=
    CollectionOfExpressionConditionPairs;

PiecewiseBranch :=
    Condition
    -> SELECTS
    -> Expression;

EquationNotation :=
    SymbolicConventionUsedToRepresentEquation;

MathematicalMarkup MAY_INCLUDE {
    MathML,
    LaTeX,
    TeX,
    AsciiMath,
    CustomSyntax
};

MathML MAY_REPRESENT {
    PresentationStructure,
    ContentStructure
};

RenderedEquation MAY_BE DerivedFrom MathematicalSourceMarkup;

EquationSource SHOULD_BE PreservedWhereAvailableForReliableMachineInterpretation;

ImageEquation :=
    EquationAvailableOnlyAsRasterOrVisualImage;

AutomaticEquationExtraction :=
    Resource
    -> DetectEquationBoundary
    -> RecogniseSymbols
    -> ParseLayout
    -> InferExpressionStructure
    -> GenerateEquationMetadata;

AI MAY_SUPPORT {
    EquationDetection,
    FormulaRecognition,
    SymbolDisambiguation,
    StructureParsing,
    SemanticInterpretation
};

InferredEquationStructure SHOULD_HAVE ConfidenceWhereUncertain;

EquationConfidence :=
    EstimatedSupportForInferredEquationIdentityStructureOrSemantics;

SymbolDisambiguation :=
    AmbiguousSymbol
    + EquationContext
    -> IntendedMathematicalEntityOrRole;

SameGlyph MAY_REPRESENT DifferentSymbolsOrRoles;

ImplicitMultiplication :=
    MultiplicationRepresentedWithoutExplicitOperatorSymbol;

Parser MAY_INFER MultiplicationFromAdjacencyAccordingToNotationRules;

EquationValidation MAY_CHECK {
    Identifier,
    BalancedDelimiters,
    OperatorArity,
    OperandPresence,
    ParseCompleteness,
    ReferenceResolution
};

IF DelimitersUnbalanced
THEN StructuralValidation := violation_or_warning;

IF BinaryOperatorMissingOperand
THEN StructuralValidation := violation;

IF ParseTreeContainsUnresolvedCriticalSymbol
THEN SemanticConfidence SHOULD_DECREASE;

EquationCompleteness :=
    DegreeToWhichRequiredSymbolsOperatorsOperandsAndRelationshipsAreRepresented;

EquationConsistency :=
    DegreeToWhichParsedStructureMatchesNotationAndOperatorRules;

EquationIntegrity :=
    PreservationOfValidSymbolIdentityGroupingRelationshipsAndOrder;

EquationQuality MAY_INCLUDE {
    Completeness,
    Consistency,
    Integrity,
    ParseConfidence,
    IdentifierStability
};

EquationProvenance MAY_INCLUDE {
    Source,
    Creator,
    ExtractionMethod,
    ParserVersion,
    Timestamp,
    Version
};

EquationVersion :=
    EquationStateAssociatedWithSpecificParentResourceVersion;

ResourceRevision MAY {
    AddEquation,
    RemoveEquation,
    RenumberEquation,
    RepositionEquation,
    ModifyEquation
};

RenumberEquation :=
    ChangeHumanReadableEquationNumberWithoutNecessarilyChangingEquationIdentity;

StableEquationIdentifier MAY_BE PreservedAcrossRenumberingWhereEquationIdentityContinues;

EquationVersionMapping :=
    OldEquationIdentifier
    -> NewEquationIdentifierOrIdentifiers;

EquationModification SHOULD_TRIGGER RevalidationOf {
    ParseTree,
    CrossReferences,
    Annotations,
    DerivedSemantics
};

CrossReference MAY_TARGET EquationUsing NumberIdentifierOrLink;

StableEquationIdentifier SHOULD_BE UsedForMachineResolution;

Annotation MAY_TARGET {
    Equation,
    Symbol,
    Subexpression,
    Operator,
    Variable
};

DescriptiveMetadata MAY_DESCRIBE EquationUsing {
    Title,
    Description,
    Subject,
    Keywords
};

StructuralMetadata DEFINES EquationCompositionGroupingAndContext;

TechnicalMetadata MAY_DESCRIBE EncodingRenderingOrSourceFormat;

PreservationMetadata MAY_REQUIRE OriginalEquationSourceAndNotationForLongTermInterpretation;

EquationIndex :=
    SearchStructureMappingEquationMetadataSymbolsAndNormalisedStructureToParentResource;

EquationSearch MAY_SUPPORT {
    TextualFormulaSearch,
    SymbolSearch,
    StructuralSearch,
    SemanticSearch
};

FormulaNormalisation MAY_REDUCE SuperficialNotationDifferences;

Normalisation MUST_NOT CollapseMathematicallyDistinctExpressionsIncorrectly;

StructuralEquationSearch :=
    QueryExpressionTree
    -> MatchCompatibleSubtreesOrPatterns
    -> ReturnEquations;

SemanticEquationSearch MAY_USE {
    MathematicalConcepts,
    Variables,
    Operators,
    ExpressionStructure,
    Embeddings
};

VectorSimilarity MAY_SUPPORT FormulaRetrieval
BUT DoesNotEstablish MathematicalEquivalence;

MathematicalEquivalence :=
    TwoExpressionsRepresentSameValueOrRelationshipUnderDefinedAssumptions;

SyntacticDifference != MathematicalDifferenceByDefinition;

EquivalenceChecking MAY_REQUIRE SymbolicReasoningBeyondStructuralMetadata;

KnowledgeGraph MAY_REPRESENT EquationAsNodeWithLinkedVariablesFunctionsAndConcepts;

ExpressionTree MAY_BE ConvertedTo GraphRepresentation;

RAG MAY_USE EquationAs {
    RetrievalUnit,
    MathematicalEvidence,
    ContextualFormula
};

EquationAwareRAG SHOULD_PRESERVE {
    EquationIdentifier,
    ParentSection,
    OriginalNotation,
    ParsedStructure,
    Provenance
};

MetadataRepository MAY_STORE EquationStructuralMetadata;

MetadataRegistry MAY_REGISTER EquationPropertiesOperatorsAndStructuralTypes;

Accessibility MAY_REQUIRE TextualOrMathAccessibleRepresentationOfEquation;

MathMLOrEquivalentSemanticMarkup MAY_IMPROVE AssistiveTechnologyInterpretation;

ImageOnlyEquation MAY_HAVE PoorAccessibilityWithoutAlternativeRepresentation;

EquationSecurity MAY_INCLUDE {
    ParserInputValidation,
    MacroOrCodeExecutionRestrictions,
    AccessControl,
    ProvenanceIntegrity,
    ChangeAuthorisation
};

MachineReadableEquation SHOULD_PRESERVE {
    EquationIdentifier,
    ParentResourceIdentifier,
    OriginalNotation,
    ExpressionTree,
    Symbols,
    Operators,
    Relationships,
    Version,
    Provenance
};

# ---------- SEMANTIC REASONING ----------
IF ResourceComponentRepresentsMathematicalLogicalOrSymbolicEquation
THEN EquationStructureClassification := supported;

IF OperatorIsBinary
THEN ExactlyTwoOperands SHOULD_BE ResolvableAccordingToOperatorSemantics;

IF GroupingExplicit
THEN Grouping SHOULD_OVERRIDE DefaultPrecedence;

IF EquationIdentifierStableAcrossRenumbering
THEN ExistingMachineLinks MAY_REMAIN Valid;

IF EquationStructureChanges
THEN DerivedParseSemanticAndSearchRepresentations SHOULD_BE Recomputed;

IF SameGlyphOccursWithDifferentContext
THEN SymbolRole SHOULD_BE ResolvedContextually;

IF EquationImageRecognitionConfidenceLow
THEN AutomaticAuthoritativeParsing SHOULD_BE Restricted;

IF ExpressionTreesDiffer
THEN MathematicalEquivalence MAY_STILL_EXIST
AND RequiresAdditionalReasoning;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "equation structure" ~= "mathematical expression structure";
    "equation identifier" ~= "equation ID";
    "expression tree" ~= "mathematical syntax tree" WHEN structural_context;
    "operand" ~= "operator argument" WHEN operator_context;
    "function argument" ~= "function operand" WHEN compatible_context;
    "left-hand side" ~= "LHS";
    "right-hand side" ~= "RHS";
    "subexpression" ~= "nested expression";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_PARENT_RESOURCE(q) ->
    IDENTIFY_EQUATION(q) ->
    RESOLVE_EQUATION_IDENTIFIER(q) ->
    IDENTIFY_NOTATION_AND_NUMBER(q) ->
    TOKENISE_SYMBOLS_OPERATORS_AND_DELIMITERS(q) ->
    PARSE_EXPRESSION_STRUCTURE(q) ->
    RESOLVE_VARIABLES_FUNCTIONS_AND_GROUPING(q) ->
    IDENTIFY_VERSION_AND_PROVENANCE(q) ->
    VALIDATE_EQUATION_STRUCTURE(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_EQUATION_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        parse_consistency,
        symbol_resolution_strength,
        structural_validation,
        provenance_quality,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: EquationStructure;
    ontology: EquationStructureOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_equation:
        identify_parent_resource
        -> detect_or_receive_equation
        -> assign_equation_identifier
        -> preserve_original_notation
        -> tokenise
        -> parse_expression_tree
        -> resolve_symbols_and_functions
        -> attach_provenance
        -> validate
        -> integrate;

    equation_revision:
        preserve_previous_version
        -> apply_symbol_operator_or_structure_changes
        -> preserve_identifier_where_identity_continues
        -> regenerate_parse_and_semantic_structure
        -> revalidate
        -> update_index
        -> recompute_confidence
        -> regenerate_flow_hash;

    notation_conversion:
        preserve_source_notation
        -> convert_representation
        -> validate_structural_equivalence
        -> attach_conversion_provenance
        -> integrate;

    conflict:
        preserve_provenance
        -> compare_equation_structure_symbols_or_sources
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + EquationEntity
    + OperatorEntity
    + StructuralEntity
    + MetadataEntity
    + EquationStructure
    + ExpressionTree
    + EquationValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
EquationStructureOntology
    -> IdentifyParentResourceAndEquationBoundary
    -> AssignStableEquationIdentifier
    -> PreserveEquationNumberAndOriginalNotation
    -> TokeniseSymbolsOperatorsAndDelimiters
    -> ParseOperandsFunctionsGroupsAndRelations
    -> BuildExpressionAndSyntaxTrees
    -> ResolveVariablesConstantsAndSymbolRoles
    -> ValidateArityGroupingAndStructuralCompleteness
    -> StoreAndVersionEquationMetadata
    -> IndexForFormulaStructuralAndSemanticSearch
    -> PreserveEquationContextForRAGAndKnowledgeGraphs
    -> MaintainCrossVersionEquationMappings
    -> MaintainReliableEquationStructureKnowledge;

END FLOW