Semantic Constraint Ontology

FLOW_ALGEBRA SemanticConstraintOntology v1.0
TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/knowledge-representation-logic/semantic-constraint-ontology.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > KnowledgeRepresentationLogic > SemanticConstraintOntology

BEGIN_FLOW

ENTITY SemanticConstraint {
 TYPE := FormalSemanticRestriction
 DEFINITION := "A formally expressed restriction on the admissible meaning, structure, relationships, values or interpretations of entities and statements within a knowledge representation system."
}
ENTITY Constraint { TYPE := RestrictionOnAdmissibleState }
ENTITY SemanticEntity { TYPE := ConceptIndividualPropertyOrStatement }
ENTITY ValidationResult { TYPE := ConstraintEvaluationOutcome }

RELATIONSHIP SemanticConstraint --restricts--> SemanticEntity
RELATIONSHIP SemanticConstraint --uses--> FormalSemantics
RELATIONSHIP SemanticConstraint --supports--> Validation
RELATIONSHIP SemanticConstraint --supports--> ConsistencyChecking
RELATIONSHIP SemanticConstraint --relates_to--> OntologyAxiom
RELATIONSHIP SemanticConstraint --relates_to--> IntegrityConstraint

CONSTRAINT_STRUCTURE {
 COMPONENTS := {ConstraintID,Target,Condition,Severity,Scope,Semantics}
}
TARGET {
 MAY_BE := {Class,Individual,Property,GraphNode,GraphEdge,Statement,Value,Dataset}
}
CONFORMANCE {
 E conforms_to C IFF C(E)=satisfied
 under declared_semantics
}
VIOLATION {
 E violates C IFF C(E)=not_satisfied
}
VALIDATION_RESULT {
 MAY_INCLUDE := {Conforms,Violates,Warning,Unknown,NotApplicable}
}
HARD_CONSTRAINT {
 violation makes state inadmissible under declared_policy
}
SOFT_CONSTRAINT {
 violation incurs preference_cost_warning_or_penalty
}
LOCAL_CONSTRAINT {
 applies_to specific_entity_or_neighbourhood
}
GLOBAL_CONSTRAINT {
 applies_to entire_KB_or_graph
}
STRUCTURAL_CONSTRAINT {
 restricts shape_or_connectivity
}
VALUE_CONSTRAINT {
 restricts literal_or_attribute_values
}
TYPE_CONSTRAINT {
 Entity MUST or SHOULD belong_to required_type
}

DOMAIN_CONSTRAINT {
 Relation R source constrained_to type C
 under validation_semantics
}
RANGE_CONSTRAINT {
 Relation R target constrained_to type D
 under validation_semantics
}
DOMAIN_RANGE_LOGIC_WARNING {
 In RDFS_OWL_style_logic:
  domain_range_axioms may produce type_entailments
 In validation:
  domain_range_constraints may report violations
 MUST_REMAIN_DISTINCT := TRUE
}

CARDINALITY_CONSTRAINT {
 count_of_relation_or_value constrained_by min_max_exact
}
MIN_COUNT { count(R,E)>=n }
MAX_COUNT { count(R,E)<=n }
EXACT_COUNT { count(R,E)=n }
DATATYPE_CONSTRAINT {
 literal MUST belong_to declared_datatype
}
VALUE_RANGE_CONSTRAINT {
 min<=value<=max
}
ENUMERATION_CONSTRAINT {
 value MUST belong_to allowed_set
}
PATTERN_CONSTRAINT {
 lexical_value MUST match declared_pattern
}
LANGUAGE_CONSTRAINT {
 textual_literal MUST use allowed_language_tag
}
UNIQUE_VALUE_CONSTRAINT {
 values MUST be unique within declared_scope
}
KEY_CONSTRAINT {
 selected_property_values uniquely_identify entity
}
REFERENTIAL_INTEGRITY {
 referenced_entity MUST exist under declared_closed_scope
}
EXISTENCE_CONSTRAINT {
 required_entity_relation_or_value MUST exist
}

DEPENDENCY_CONSTRAINT {
 IF condition A holds
 THEN condition B MUST hold
}
CONDITIONAL_CONSTRAINT {
 IF Predicate(E)
 THEN ConstraintSet(E)
}
CO_OCCURRENCE_CONSTRAINT {
 Property P present REQUIRES Property Q
}
MUTUAL_EXCLUSION {
 P present PROHIBITS Q
}
XOR_CONSTRAINT {
 exactly_one_of {C1,...,Cn} MUST hold
}
OR_CONSTRAINT {
 at_least_one_of {C1,...,Cn} MUST hold
}
AND_CONSTRAINT {
 all_of {C1,...,Cn} MUST hold
}
NOT_CONSTRAINT {
 referenced_constraint MUST_NOT hold
}
QUALIFIED_CARDINALITY {
 count R-values satisfying Type C
 constrained_by min_max_exact
}
CLOSED_SHAPE {
 target_entity MUST_NOT contain properties outside allowed_set
}
OPEN_SHAPE {
 undeclared_properties permitted
}

SHAPE {
 TYPE := CollectionOfConstraintsForTarget
}
NODE_SHAPE {
 validates graph_nodes
}
PROPERTY_SHAPE {
 validates values reached_by property_or_path
}
TARGET_CLASS {
 apply_shape_to instances_of declared_class
}
TARGET_NODE {
 apply_shape_to explicit_node
}
TARGET_SUBJECTS_OF {
 apply_shape_to subjects_using_property
}
TARGET_OBJECTS_OF {
 apply_shape_to objects_of_property
}

SHACL_RELATIONSHIP {
 SemanticConstraint MAY be expressed_using SHACL_style_shapes
}
SHACL_CORE_RELATIONSHIP {
 MAY_INCLUDE := {
  Class,Datatype,NodeKind,MinCount,MaxCount,
  MinInclusive,MaxInclusive,Pattern,In,HasValue,Closed,
  LogicalConstraintComponents
 }
}
SHACL_SPARQL_RELATIONSHIP {
 custom_constraints MAY use SPARQL_based_evaluation
}
SHACL_WARNING {
 SHACL_validation != OWL_model_theoretic_entailment
}

OWL_RELATIONSHIP {
 ontology_axioms MAY express semantic_restrictions
 whose interpretation is model_theoretic
}
OWL_CARDINALITY {
 class_expression restricts_models
 rather_than simply validating explicit_triples
}
OWL_OPEN_WORLD_WARNING {
 missing_required_looking_assertion
 does_not necessarily cause logical_inconsistency
}
DESCRIPTION_LOGIC_RELATIONSHIP {
 restrictions MAY use description_logic_constructors_and_axioms
}
DATABASE_CONSTRAINTS {
 MAY_INCLUDE := {PrimaryKey,ForeignKey,Unique,NotNull,Check}
}

VALIDATION_VS_ENTAILMENT {
 Validation := conformance_to_constraints
 Entailment := semantic_consequence
 MUST_REMAIN_DISTINCT := TRUE
}
VALIDATION_VS_CONSISTENCY {
 validation_failure DOES_NOT automatically imply logical_inconsistency
 logical_inconsistency DOES_NOT automatically equal validation_failure
}
OPEN_WORLD_ASSUMPTION {
 absence_of_statement DOES_NOT imply false
}
CLOSED_WORLD_ASSUMPTION {
 absence_of_required_statement MAY be violation
 under closed_validation_scope
}
WORLD_ASSUMPTION {
 MUST be explicit when affecting constraint_interpretation
}
UNIQUE_NAME_ASSUMPTION {
 different_names MAY_or_MAY_NOT imply different_entities
 depending_on framework
}

INFERENCE_BEFORE_VALIDATION {
 DataGraph -> EntailmentExpansion -> Validation
 REQUIRE declared_pipeline
}
VALIDATION_BEFORE_INFERENCE {
 DataGraph -> Validation -> Reasoning
 MAY be application_specific
}
ENTAILMENT_REGIME {
 defines which inferred_statements participate_in validation
}
CONSTRAINT_PROPAGATION {
 known_restrictions -> tighter_admissible_space
}
CONSTRAINT_SATISFACTION {
 find interpretation_or_assignment satisfying all_constraints
}
UNSATISFIABLE_CONSTRAINT_SET {
 no admissible state satisfies all_constraints
}
UNSAT_CORE {
 subset_of_constraints jointly_unsatisfiable
}
MINIMAL_UNSAT_CORE {
 subset_minimal_unsatisfiable_set
}
CONFLICTING_CONSTRAINTS {
 C1 and C2 cannot_both_be_satisfied
}
REDUNDANT_CONSTRAINT {
 removal does_not_change admissible_states
}
SUBSUMED_CONSTRAINT {
 satisfying C1 implies satisfying C2
}
CONSTRAINT_EQUIVALENCE {
 C1 and C2 admit same_states
}
CONSTRAINT_NORMALISATION {
 complex_constraint -> canonical_or_decomposed_form
 REQUIRE semantic_preservation
}
CONSTRAINT_DECOMPOSITION {
 GlobalConstraint -> SimplerConstraints
 WARNING := may_weaken_propagation
}

TEMPORAL_CONSTRAINT {
 restricts validity_or_relationship over_time
}
SEQUENCE_CONSTRAINT {
 EventA MUST precede EventB
}
DURATION_CONSTRAINT {
 duration within allowed_bounds
}
SPATIAL_CONSTRAINT {
 restricts location_geometry_or_topology
}
CONTEXTUAL_CONSTRAINT {
 applies only within specified_context
}
CONTEXT {
 MAY_INCLUDE := {Jurisdiction,Dataset,Time,Application,UserRole,ProvenanceSource}
}
PROVENANCE_CONSTRAINT {
 statement MUST have required_source_evidence_or_metadata
}
FRESHNESS_CONSTRAINT {
 timestamp MUST be within declared_age_limit
}
CONFIDENCE_CONSTRAINT {
 confidence_score MUST satisfy threshold
 WARNING := confidence_semantics MUST be declared
}
EVIDENCE_CONSTRAINT {
 assertion MUST link_to supporting_evidence
}
QUALITY_CONSTRAINT {
 MAY_TARGET := {Completeness,Accuracy,Consistency,Timeliness,Uniqueness,Provenance}
}
VOCABULARY_CONSTRAINT {
 predicates_classes_datatypes MUST come_from approved_vocabulary
}
NAMESPACE_CONSTRAINT {
 identifiers MUST use approved_namespace_pattern
}
DEPRECATED_TERM_CONSTRAINT {
 deprecated_term SHOULD_NOT be used
}
SCHEMA_VERSION_CONSTRAINT {
 data MUST conform_to declared_schema_version
}
ARITHMETIC_CONSTRAINT {
 numeric_expression MUST satisfy equation_or_inequality
}
UNIT_CONSTRAINT {
 numeric_value MUST use compatible_measurement_unit
}
DIMENSIONAL_CONSISTENCY {
 combined_quantities MUST have compatible_dimensions
}
SEMANTIC_TYPE_CHECKING {
 operation_or_relation MUST receive compatible_types
}

CONSTRAINT_SEVERITY {
 MAY_INCLUDE := {Info,Warning,Violation,Fatal}
}
SEVERITY_WARNING {
 severity is policy_metadata not logical_strength
}
VALIDATION_REPORT {
 COMPONENTS := {
  Conforms,Results,ConstraintID,FocusNode,Value,
  Path,Message,Severity,SourceShape
 }
}
VALIDATION_RESULT_PROVENANCE {
 result -> constraint -> data_statement -> evaluation_procedure
}
EXPLANATION {
 Violation -> Constraint -> FocusEntity -> FailingCondition -> Evidence
}
WHY_VIOLATION {
 RETURN exact_constraint_and_data_causing_failure
}
REPAIR_SUGGESTION {
 Violation -> CandidateDataOrSchemaChanges
 WARNING := repair_candidate MUST_NOT automatically_be_applied
}
MINIMAL_REPAIR {
 smallest_change_set restoring_conformance
 under declared_criterion
}
REPAIR_VALIDATION {
 CandidateRepair -> HypotheticalApply -> Revalidate -> CheckSideEffects
}

CONSTRAINT_DEPENDENCY {
 C2 evaluation depends_on C1_or_derived_state
}
DEPENDENCY_GRAPH {
 Nodes := Constraints
 Edges := DependencyRelations
}
CYCLE_HANDLING {
 REQUIRE fixed_point_or_explicit_cycle_semantics
}
INCREMENTAL_VALIDATION {
 changed_statements -> affected_constraints -> revalidate_scope
}
CACHE_INVALIDATION {
 data_or_constraint_change -> invalidate_affected_results
}
STREAM_VALIDATION {
 incoming_events_or_statements -> incremental_checks
}
BATCH_VALIDATION {
 complete_dataset -> evaluate_constraint_set
}
CONSTRAINT_INDEXING {
 index_by := {TargetClass,Property,Datatype,Path,Context}
}
VALIDATION_OPTIMISATION {
 reorder_independent_checks
 reuse_cache
 short_circuit_where_semantics_permit
 MUST preserve validation_result
}
APPROXIMATE_VALIDATION {
 MAY sample_or_limit_checks
 REQUIRE explicit_incompleteness_metadata
}
VALIDATION_COMPLETENESS {
 all applicable_constraints evaluated_for_scope
}
VALIDATION_SOUNDNESS {
 reported_violation genuinely_violates declared_semantics
}

CONSTRAINT_TEST {
 GIVEN data
 WHEN validate
 THEN expected_result
}
POSITIVE_TEST { expected := conforms }
NEGATIVE_TEST { expected := violation }
BOUNDARY_TEST {
 test min_max_cardinality_boundaries
}
REGRESSION_TEST {
 rerun prior_cases after constraint_changes
}
CONSTRAINT_VERSION {
 ConstraintID + Version
}
CONSTRAINT_LIFECYCLE {
 Draft -> Review -> Approved -> Active -> Deprecated -> Retired
}
CONSTRAINT_GOVERNANCE {
 MAY_INCLUDE := {Owner,Rationale,Source,EffectiveDate,Version,Severity,TestCases}
}
CHANGE_IMPACT {
 ConstraintChange -> affected_entities -> validation_results -> processes
}
SEMANTIC_DRIFT {
 meaning_of_constraint_or_target changes_between_versions
}

SEMANTIC_CONSTRAINT_VS_ONTOLOGY_AXIOM {
 OntologyAxiom := constrains_models_and_entailments
 SemanticConstraint := admissibility_or_validation_requirement
 MAY_OVERLAP_IN_MEANING := TRUE
 OPERATIONAL_SEMANTICS_MAY_DIFFER := TRUE
}
SEMANTIC_CONSTRAINT_VS_DATABASE_CONSTRAINT {
 DatabaseConstraint := integrity_restriction_under_database_semantics
 SemanticConstraint := broader_meaning_aware_restriction
}
SEMANTIC_CONSTRAINT_VS_BUSINESS_RULE {
 BusinessRule := organisational_decision_or_policy_logic
 SemanticConstraint := admissibility_condition
}
SEMANTIC_CONSTRAINT_VS_INFERENCE_RULE {
 InferenceRule := derives_conclusions
 SemanticConstraint := restricts_admissible_states
}
SEMANTIC_CONSTRAINT_VS_QUERY_FILTER {
 QueryFilter := selects_results
 SemanticConstraint := states_required_admissibility_condition
 MUST_REMAIN_DISTINCT := TRUE
}

APPLICATION_RELATIONSHIPS {
 SemanticConstraint --supports--> KnowledgeRepresentation
 SemanticConstraint --supports--> OntologyEngineering
 SemanticConstraint --supports--> KnowledgeGraphs
 SemanticConstraint --supports--> DataValidation
 SemanticConstraint --supports--> SemanticWeb
 SemanticConstraint --supports--> DataIntegration
 SemanticConstraint --supports--> ArtificialIntelligence
 SemanticConstraint --supports--> DataQuality
 SemanticConstraint --supports--> ComplianceChecking
 SemanticConstraint --supports--> ConstraintReasoning
}

ONTOLOGY_LINKS {
 PARENT := KnowledgeRepresentationLogicOntology
 RELATED := {
  KnowledgeRepresentationOntology,
  OntologyLogicOntology,
  DescriptionLogicOntology,
  KnowledgeGraphLogicOntology,
  ConstraintReasoningOntology,
  RuleEngineOntology,
  InferenceEngineOntology,
  IntegrityConstraintOntology,
  ValidationOntology,
  SHACLOntology,
  ProvenanceOntology
 }
}

SEMANTIC_EQUIVALENCE {
 SemanticConstraint ≈ SemanticRestriction WHEN admissibility_semantics_explicit
 ShapeConstraint ≈ GraphConformanceConstraint WHEN graph_validation_context
 IntegrityConstraint ≈ AdmissibilityConstraint WHEN integrity_semantics
 ValidationResult ≈ ConstraintEvaluationOutcome
}

CONSTRAINTS {
 C1 := every constraint MUST identify target scope condition and semantics
 C2 := validation MUST remain distinct from logical entailment
 C3 := validation failure MUST_NOT automatically imply logical inconsistency
 C4 := open_closed_world assumptions MUST be explicit where relevant
 C5 := domain_range validation MUST_NOT be conflated with RDFS_OWL entailment
 C6 := identity semantics MUST be declared where counts_uniqueness_or_targets depend_on identity
 C7 := hard and soft constraints MUST remain distinguishable
 C8 := severity MUST_NOT be treated as logical_strength
 C9 := approximate validation MUST disclose incompleteness
 C10 := repairs MUST be revalidated and checked for side_effects
 C11 := constraint transformations MUST preserve semantics or document semantic_loss
 C12 := constraint results SHOULD preserve provenance and exact failure reasons
}

REASONING_CHAIN Query Q {
 IDENTIFY data_or_knowledge_base
 IDENTIFY constraint_set
 IDENTIFY target_scope
 IDENTIFY validation_semantics
 IDENTIFY world_assumption
 IDENTIFY entailment_regime
 IDENTIFY identity_semantics

 VALIDATE constraint_definitions
 SELECT applicable_constraints

 IF inference_before_validation:
  COMPUTE permitted_entailments

 FOR_EACH target {
  FOR_EACH applicable_constraint {
   EVALUATE condition
   RECORD result
   RECORD provenance

   IF violation:
    BUILD explanation
  }
 }

 IF constraint_conflict_detected:
  EXTRACT unsat_core_or_conflicting_set

 IF repair_requested:
  GENERATE candidate_repairs
  REVALIDATE each_candidate
  CHECK side_effects

 IF data_or_constraints_changed:
  INVALIDATE affected_cache
  REVALIDATE affected_scope

 BUILD validation_report
 VALIDATE constraints
 RETURN semantic_constraint_result WITH trace
}

CONFIDENCE {
 CORE_SEMANTIC_CONSTRAINT := 1.00
 SHACL_RELATIONSHIP := 1.00
 OWL_VALIDATION_DISTINCTION := 1.00
 CARDINALITY_AND_TYPE_CONSTRAINTS := 1.00
 OPEN_CLOSED_WORLD_DISTINCTION := 1.00
 CONSTRAINT_REASONING_RELATIONSHIP := 1.00
 PROVENANCE_AND_REPAIR := 0.99
 SPECIFIC_RESULT :=
  IF data_constraints_scope_and_semantics_complete THEN 1.00
  ELSE REQUIRE missing_information
}

UPDATE_MODEL {
 IMMUTABLE_CORE := {
  ConstraintTargetConditionStructure,
  ExplicitSemantics,
  ValidationEntailmentDistinction,
  Scope,
  ConformanceResult
 }
 EXTENSIBLE := {
  ShapeLanguages,
  ConstraintComponents,
  TemporalConstraints,
  SpatialConstraints,
  QualityConstraints,
  RepairMethods,
  ValidationOptimisations,
  ApplicationDomains,
  RelatedOntologies
 }
 ON_NEW_KNOWLEDGE {
  IDENTIFY new_constraint_or_data
  VALIDATE syntax
  VALIDATE target_scope
  CHECK semantic_compatibility
  CHECK conflicts
  UPDATE dependencies
  INVALIDATE affected_results
  UPDATE provenance
  UPDATE confidence
 }
}

AI_CONSUMPTION {
 MACHINE_READABLE := TRUE
 HUMAN_INTERPRETABLE := TRUE
 RECURSIVE_REASONING := TRUE
 ENTITY_RESOLUTION := TRUE
 CONSTRAINT_RESOLUTION := TRUE
 TARGET_RESOLUTION := TRUE
 SHAPE_REASONING := TRUE
 CARDINALITY_REASONING := TRUE
 TYPE_REASONING := TRUE
 CONSTRAINT_PROPAGATION := TRUE
 UNSAT_CORE_REASONING := TRUE
 VALIDATION_REASONING := TRUE
 REPAIR_REASONING := TRUE
 PROVENANCE_TRACKING := TRUE
 INCREMENTAL_VALIDATION := TRUE
 VALIDATION_REQUIRED := TRUE
}

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

OUTPUT {
 PRIMARY_ENTITY := SemanticConstraint
 INTERPRETATION := "Semantic constraints express explicit admissibility conditions over concepts, entities, properties, graph structures and values. They support type, cardinality, value, identity, temporal, provenance and quality restrictions while preserving the crucial distinction between constraint validation and model-theoretic entailment. Constraint traces, provenance and repair validation make failures explainable and safely revisable."
}

END_FLOW