Civilisation Atlas | Validation, Conflict and Versioning Protocol

article:
  id: CA-UI-009
  title: Validation, Conflict and Versioning Protocol
  version: 1.0
  status: canonical
  type: specification
  parent_protocol: CA-UI-001
  depends_on:
    - CA-UI-002
    - CA-UI-003
    - CA-UI-004
    - CA-UI-005
    - CA-UI-006
    - CA-UI-007
    - CA-UI-008

purpose: >
  Protect Civilisation Atlas from invalid objects,
  unsupported coordinates, duplicate identities,
  contradictory claims, silent schema drift,
  broken relationships and incompatible versions.

INGESTION CREATES CANDIDATES.
VALIDATION CREATES TRUST.
CONFLICT RECORDS PRESERVE DISAGREEMENT.
VERSIONING PRESERVES CONTINUITY.

Input
  ↓
Schema Validation
  ↓
Identity Validation
  ↓
Scale Validation
  ↓
Coordinate Validation
  ↓
Relationship Validation
  ↓
Evidence Validation
  ↓
Conflict Detection
  ↓
Version Compatibility
  ↓
Registration Decision

validation_layers:
  - syntax
  - schema
  - identity
  - semantic
  - scale
  - temporal
  - coordinate
  - relationship
  - dependency
  - evidence
  - provenance
  - crosswalk
  - version

validation_result:
  validation_id: required
  target_id: required
  target_type: required
  validator: required
  validation_date: required
  checks:
    passed: []
    warnings: []
    failed: []
    unresolved: []
  severity:
    - valid
    - valid_with_warning
    - provisional
    - review_required
    - invalid
    - quarantined
  registration_action:
    - register
    - register_provisionally
    - update_existing
    - hold_for_review
    - quarantine
    - reject

severity_levels:
  INFO:
    effect: no_registration_block
  WARNING:
    effect: register_with_visible_warning
  MATERIAL:
    effect: provisional_registration_only
  CRITICAL:
    effect: registration_blocked
  FATAL:
    effect: reject_or_quarantine

function validate_schema(record):
    require(record.schema_id)
    require(record.schema_version)
    verify_required_fields(record)
    verify_field_types(record)
    verify_allowed_values(record)
    verify_identifier_format(record)
    verify_internal_references(record)
    reject_unknown_required_fields()
    preserve_extension_fields_if_namespaced()
    return schema_validation_result

extension_rule:
  custom_fields_allowed: true
  namespace_required: true
  silent_core_schema_change: false

external_extension:
  ext.archaeology.stratigraphic_layer: Layer_IV
  ext.economics.price_index_basis: 2015

identity_validation:
  checks:
    - canonical_name_present
    - object_type_present
    - aliases_checked
    - temporal_scope_checked
    - spatial_scope_checked
    - external_identifiers_checked
    - duplicate_search_completed

function validate_identity(object):
    matches = search_registry(
        canonical_name,
        aliases,
        identifiers,
        time,
        space,
        object_type
    )
    if exact_duplicate(matches):
        return MERGE_REQUIRED
    if probable_duplicate(matches):
        return REVIEW_REQUIRED
    if conflicting_identity(matches):
        return CONFLICT_RECORD_REQUIRED
    return VALID_IDENTITY

duplicate_resolution:
  duplicate_id: required
  candidate_objects: required
  resolution:
    - same_object
    - related_objects
    - historical_alias
    - successor_object
    - predecessor_object
    - distinct_objects
    - unresolved
  canonical_survivor: optional
  redirect_ids: []
  merged_fields: []
  preserved_conflicts: []
  evidence_ids: required

MERGE IDENTITIES.
DO NOT MERGE DISAGREEMENTS AWAY.

function validate_scale(record):
    require(record.system_level)
    compare:
        evidence_level
        claim_level
        coordinate_level
        relationship_level
    reject_if:
        individual_evidence_claims_planetary_fact
        local_event_claims_civilisational_transition
        state_coordinate_is_assigned_to_humanity
        planetary_average_is_assigned_to_every_region
    return scale_result

scale_status:
  - exact_match
  - valid_aggregation
  - valid_disaggregation
  - extrapolated_with_warning
  - incompatible

temporal_validation:
  required:
    - observation_date
    - valid_time_scope
  checks:
    - source_date_matches_claim_period
    - coordinate_is_dated
    - relationship_status_is_dated
    - superseded_records_are_marked
    - forecasts_are_not_marked_as_observations

A VALID HISTORICAL CLAIM
MAY BE AN INVALID PRESENT-DAY CLAIM.

function validate_coordinate(coordinate):
    require(coordinate.target_object)
    require(coordinate.system_level)
    require(coordinate.observation_date)
    require(coordinate.evidence_ids)
    verify_capability_stage(coordinate.capability)
    verify_lifecycle_phase(coordinate.lifecycle)
    verify_habitat_level(coordinate.habitat)
    reject_if:
        invention_only_supports_stage_change
        temporary_presence_supports_habitat_independence
        high_capability_is_treated_as_health
        lifecycle_is_inferred_from_capability_alone
        coordinate_is_permanent_and_undated
    return coordinate_validation

stage_change_test:
  invention: required
  adoption: required
  scaling: required
  institutionalisation: required
  education: required
  dependency: required
  structural_consequence: required

function validate_stage_change(system, proposed_stage):
    if not invention:
        return FAIL
    if not adoption:
        return FAIL
    if not scaling:
        return FAIL
    if not institutionalisation:
        return FAIL
    if not education_and_reproduction:
        return FAIL
    if not structurally_consequential:
        return FAIL
    return PASS

function validate_habitat_claim(system, proposed_level):
    evaluate:
        food
        water
        energy
        atmosphere
        maintenance
        medicine
        reproduction
        governance
        education
        industrial_replacement
        knowledge_continuity
    remove_external_support()
    if terminal_failure_occurs:
        reject_independence_claim()
    return highest_sustainable_level

PRESENCE ≠ SETTLEMENT
SETTLEMENT ≠ AUTONOMY
AUTONOMY ≠ CIVILISATIONAL INDEPENDENCE

function validate_relationship(edge):
    require(valid_object(edge.source))
    require(valid_predicate(edge.predicate))
    require(valid_object(edge.target))
    require(edge.system_level)
    require(edge.temporal_scope)
    require(edge.evidence_ids)
    if edge.class == causal:
        require(edge.mechanism)
    if edge.class == dependency:
        require(edge.required_function)
        require(edge.criticality)
        require(edge.failure_effect)
    if edge.class == comparative:
        require(shared_comparison_dimension)
    reject_if:
        predicate_is_undefined
        direction_is_ambiguous
        scale_is_inherited_silently
        correlation_is_marked_as_causation
    return relationship_validation

dependency_validation:
  required:
    - dependent_object
    - provider_object
    - required_function
    - criticality
    - substitutability
    - redundancy
    - failure_effect

function validate_dependency(dependency):
    simulate_provider_removal()
    verify_required_function()
    verify_alternative_providers()
    verify_failure_consequence()
    if dependency.criticality == existential
    and failure_effect != civilisational:
        flag_inconsistency()
    return dependency_validation

function validate_evidence(evidence):
    require(valid_source_id)
    require(exact_source_location)
    require(extraction_record)
    require(temporal_scope)
    require(system_level)
    require(uncertainty)
    require(confidence)
    reject_if:
        source_cannot_be_traced
        quotation_cannot_be_located
        interpretation_is_marked_as_observation
        machine_output_is_self_validated
        evidence_is_outside_claim_scope
    return evidence_validation

provenance_validation:
  required_chain:
    - source
    - evidence
    - interpretation_or_direct_observation
    - claim
    - atlas_mapping
    - output

function validate_provenance(target):
    chain = retrieve_provenance_chain(target)
    if chain.has_missing_link:
        return INVALID
    if transformation_is_unrecorded:
        return INVALID
    if information_loss_is_unrecorded:
        return WARNING
    return VALID

function validate_crosswalk(crosswalk):
    require(original_model_preserved)
    require(source_terms_defined)
    require(mapping_types_declared)
    require_information_loss_record()
    preserve_unmapped_concepts()
    preserve_conflicting_assumptions()
    reject_if:
        external_theory_is_relabelled_as_atlas_theory
        partial_mapping_is_marked_direct
        analogy_is_marked_equivalence
        source_limitations_are_removed
    return crosswalk_validation

conflict_classes:
  IDENTITY:
    definition: >
      Two records disagree about what an object is.
  CLASSIFICATION:
    definition: >
      Records assign different object types or system levels.
  COORDINATE:
    definition: >
      Different supported Atlas positions exist.
  EVIDENCE:
    definition: >
      Sources report incompatible observations.
  INTERPRETATION:
    definition: >
      The same evidence produces different explanations.
  CAUSAL:
    definition: >
      Models disagree about what caused an outcome.
  SCALE:
    definition: >
      Claims operate at incompatible system levels.
  TEMPORAL:
    definition: >
      Claims refer to different periods but appear contradictory.
  DEFINITION:
    definition: >
      Terms use incompatible meanings.
  VERSION:
    definition: >
      Records depend on incompatible schema or ontology versions.

conflict:
  conflict_id: required
  conflict_class: required
  target_id: required
  opened_at: required
  positions:
    - position_id: required
      claim_ids: required
      evidence_ids: required
      framework_ids: optional
      confidence: required
  shared_ground: []
  disputed_elements: []
  likely_source_of_conflict: []
  material_effect: required
  resolution_status:
    - unresolved
    - conditionally_reconciled
    - scale_dependent
    - time_dependent
    - definition_dependent
    - resolved
    - superseded
  canonical_effect:
    - none
    - warning
    - provisional_only
    - canonical_status_suspended

function detect_conflicts(new_record):
    comparable_records =
        retrieve_same_target_and_scope(new_record)
    conflicts = []
    for existing in comparable_records:
        if logically_incompatible(new_record, existing):
            conflict_type =
                classify_conflict(
                    new_record,
                    existing
                )
            conflicts.append(
                create_conflict_record(
                    new_record,
                    existing,
                    conflict_type
                )
            )
    return conflicts

function resolve_conflict(conflict):
    align:
        definitions
        scales
        dates
        methods
        evidence_types
        assumptions
    if conflict_disappears_after_alignment:
        return CONDITIONALLY_RECONCILED
    compare:
        source_quality
        directness
        methodology
        independence
        scale_match
        temporal_match
    if one_position_is_invalid:
        mark_invalid_position()
    else:
        preserve_multiple_positions()
    return updated_conflict

DISAGREEMENT IS DATA.
RESOLUTION IS NOT FORCED.

canonical_status:
  CANDIDATE:
    definition: submitted_but_not_validated
  PROVISIONAL:
    definition: usable_with_material_uncertainty
  CANONICAL:
    definition: validated_reference_record
  DISPUTED:
    definition: canonical_claim_has_active_material_conflict
  DEPRECATED:
    definition: retained_but_no_longer_preferred
  SUPERSEDED:
    definition: replaced_by_newer_record
  RETIRED:
    definition: removed_from_active_runtime_but_preserved

function promote_to_canonical(record):
    require(schema_valid)
    require(identity_valid)
    require(scale_valid)
    require(provenance_complete)
    require(evidence_threshold_met)
    require(no_unresolved_critical_conflict)
    require(version_compatible)
    record.status = CANONICAL
    return record

version:
  schema_version: required
  ontology_version: required
  object_version: required
  runtime_version: required
  article_version: optional
  effective_date: required

SCHEMA VERSION
= DATA STRUCTURE
ONTOLOGY VERSION
= MEANING OF TERMS
OBJECT VERSION
= STATE OF ONE OBJECT
RUNTIME VERSION
= PROCESSING LOGIC
ARTICLE VERSION
= PUBLISHED HUMAN INTERFACE

semantic_versioning:
  format: MAJOR.MINOR.PATCH
  MAJOR:
    trigger:
      - incompatible_schema_change
      - coordinate_redefinition
      - identifier_rule_change
      - ontology_break
  MINOR:
    trigger:
      - backward_compatible_field_addition
      - new_object_type
      - new_predicate
      - new_diagnostic
  PATCH:
    trigger:
      - typo_fix
      - clarification
      - metadata_correction
      - non_structural_update

version_record:
  version_id: required
  target_id: required
  previous_version: optional
  new_version: required
  change_type: required
  change_summary: required
  changed_fields: []
  reason: required
  migration_required: required
  migration_rule: optional
  approved_by: required
  effective_date: required

history_rule:
  overwrite_previous_version: false
  preserve_old_versions: true
  preserve_old_coordinates: true
  preserve_old_claims: true
  preserve_old_relationships: true

UPDATE THE PRESENT RECORD.
DO NOT DELETE THE HISTORICAL RECORD.

function update_object(object_id, changes):
    current = retrieve_current_version(object_id)
    new_version = clone(current)
    apply(changes, new_version)
    validate(new_version)
    link:
        previous_version = current.version
        new_version = increment_version(current)
    preserve(current)
    activate(new_version)
    return new_version

coordinate_update:
  coordinate_id: required
  target_object: required
  previous_coordinate: required
  new_coordinate: required
  observation_date: required
  change_reason: required
  evidence_ids: required

A NEW COORDINATE
DOES NOT INVALIDATE
THE OLD COORDINATE.
IT CREATES MOTION HISTORY.

ontology_change:
  change_id: required
  affected_term: required
  previous_definition: required
  new_definition: required
  reason:
    - clarification
    - evidence_change
    - scope_change
    - conceptual_split
    - conceptual_merge
    - error_correction
  affected_objects: []
  affected_articles: []
  affected_queries: []
  migration_plan: required

concept_split:
  old_concept: required
  new_concepts: required
  mapping:
    - old_records_to_review
    - automatic_migrations
    - ambiguous_records
  redirects: required

OLD:
Lifecycle Stage
SPLIT INTO:
Lifecycle Phase
+
Lifecycle Condition

concept_merge:
  source_concepts: required
  canonical_concept: required
  preserved_aliases: required
  semantic_loss: required
  migration_rule: required

compatibility:
  backward_compatible:
    definition: >
      New runtime can correctly interpret old records.
  forward_compatible:
    definition: >
      Old runtime can safely ignore unsupported new fields.
  incompatible:
    definition: >
      Migration is required before records can be compared.

function check_compatibility(record, runtime):
    if record.schema_major != runtime.schema_major:
        return MIGRATION_REQUIRED
    if record.schema_minor > runtime.schema_minor:
        return PARTIAL_SUPPORT
    return COMPATIBLE

migration:
  migration_id: required
  from_version: required
  to_version: required
  target_records: required
  transformations:
    - field_rename
    - field_split
    - field_merge
    - value_translation
    - identifier_redirect
    - coordinate_recalculation
  information_loss: required
  reversible: required
  validation_required: true

deprecation:
  target_id: required
  deprecated_from: required
  replacement_id: optional
  reason: required
  redirect: required
  historical_access: required

DEPRECATED ≠ DELETED

registry_integrity:
  checks:
    - unique_canonical_ids
    - valid_redirects
    - no_broken_relationship_targets
    - no_orphaned_evidence
    - no_unversioned_canonical_records
    - no_circular_redirects
    - no_active_superseded_records

function audit_registry():
    detect_duplicate_ids()
    detect_broken_edges()
    detect_orphan_records()
    detect_invalid_versions()
    detect_unresolved_redirects()
    detect_schema_drift()
    detect_canonical_records_without_provenance()
    return audit_report

function detect_schema_drift(records):
    observed_fields =
        collect_unregistered_fields(records)
    observed_meanings =
        detect_term_usage_changes(records)
    if unregistered_field_frequency > threshold:
        create_schema_gap()
    if canonical_term_meaning_has_shifted:
        create_ontology_conflict()
    return drift_report

REPEATED EXCEPTIONS
MAY INDICATE
THE SCHEMA MUST EVOLVE.

change_authority:
  patch_change:
    approval: maintainer
  minor_change:
    approval:
      - schema_review
      - compatibility_check
  major_change:
    approval:
      - ontology_review
      - migration_plan
      - affected_registry_audit
      - canonical_release

release_manifest:
  release_id: required
  release_version: required
  release_date: required
  included:
    schemas: []
    ontology_terms: []
    objects: []
    relationships: []
    crosswalks: []
    runtimes: []
    articles: []
  changes:
    added: []
    modified: []
    deprecated: []
    superseded: []
    migrated: []
  unresolved_conflicts: []
  known_limitations: []

function validate_and_register(record):
    syntax = validate_syntax(record)
    schema = validate_schema(record)
    identity = validate_identity(record)
    scale = validate_scale(record)
    temporal = validate_time(record)
    semantic = validate_semantics(record)
    evidence = validate_evidence(record)
    provenance = validate_provenance(record)
    conflicts = detect_conflicts(record)
    version = check_compatibility(
        record,
        CURRENT_RUNTIME
    )
    result = aggregate_validation(
        syntax,
        schema,
        identity,
        scale,
        temporal,
        semantic,
        evidence,
        provenance,
        conflicts,
        version
    )
    return registration_decision(result)

function registration_decision(validation):
    if validation.has_fatal_failure:
        return REJECT
    if validation.has_critical_failure:
        return QUARANTINE
    if validation.has_material_uncertainty:
        return REGISTER_PROVISIONALLY
    if validation.has_warning:
        return REGISTER_WITH_WARNING
    return REGISTER_CANONICALLY

query:
  "Why is this object provisional?"
return:
  failed_checks
  warnings
  evidence_gaps
  conflicts
  required_review

query:
  "What changed between versions?"
return:
  field_diff
  definition_diff
  evidence_diff
  coordinate_diff
  migration_history

query:
  "Which canonical claims are disputed?"
return:
  active_conflicts
  affected_objects
  competing_positions
  confidence
  canonical_effect

minimum_canonical_requirements:
  object_identity: valid
  system_level: valid
  temporal_scope: valid
  provenance: complete
  evidence_confidence: above_threshold
  schema_version: compatible
  critical_conflicts: none
  validation_status: passed

canonical_rule: >
  No Atlas object, coordinate, relationship, dependency,
  crosswalk or claim becomes canonical without schema,
  identity, scale, temporal, evidential, provenance and
  version validation. Conflicts must remain visible, and
  historical versions must remain recoverable.

VALIDATION PREVENTS BAD DATA
FROM BECOMING CANONICAL.
CONFLICT RECORDS PREVENT
DISAGREEMENT FROM BEING ERASED.
VERSIONING PREVENTS
THE ATLAS FROM FORGETTING ITS OWN HISTORY.
MIGRATION ALLOWS
THE ARCHITECTURE TO EVOLVE.
DEPRECATION PRESERVES
OLD ROUTES WITHOUT KEEPING THEM ACTIVE.
THE ATLAS MAY CHANGE.
ITS LINEAGE MUST NOT BREAK.