Creator Ontology

FLOW ALGEBRA
Creator Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/provenance-metadata/creator-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "CreatorOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := ProvenanceMetadata
ONTOLOGY := CreatorOntology

ENTITY Creator {
    definition:
        "An identifiable agent responsible for originating, producing,
         authoring, generating or otherwise bringing a resource, entity,
         assertion, dataset, model or metadata object into existence.";
    objectives: [
        CreatorIdentification,
        Attribution,
        ResponsibilityTracking,
        ContributionContext,
        Provenance,
        AuthorityAssessment,
        MachineInterpretability
    ];
}

CreatorEntity := {
    Creator,
    CreatorIdentifier,
    CreatorRecord,
    CreatorRole,
    CreatorName,
    CreationActivity,
    CreatedResource,
    CreatorAttribution
};

AgentEntity := {
    Person,
    Organisation,
    Institution,
    SoftwareAgent,
    AIModel,
    AutomatedService,
    CollectiveAgent
};

ContributionEntity := {
    Author,
    Originator,
    Developer,
    Researcher,
    Photographer,
    Composer,
    Editor,
    Contributor
};

MetadataEntity := {
    Provenance,
    Timestamp,
    Version,
    Evidence,
    Confidence,
    Authority,
    Affiliation,
    Rights
};

Creator CREATES CreatedResource;
CreatedResource WAS_CREATED_BY Creator;
CreationActivity GENERATES CreatedResource;
CreationActivity WAS_ASSOCIATED_WITH Creator;
Creator HAS_ROLE CreatorRole;
CreatorAttribution LINKS Creator TO CreatedResource;
Provenance SUPPORTS CreatorAttribution;

CreatorFlow :=
    Resource
    -> IdentifyCreationEvent
    -> IdentifyCandidateCreator
    -> ResolveCreatorIdentity
    -> DetermineCreatorRole
    -> LinkCreatorToCreationActivity
    -> AttachCreatorAttribution
    -> RecordTimestampAndVersion
    -> AttachEvidenceAndProvenance
    -> ValidateCreatorRelationship
    -> StoreCreatorRecord
    -> EnableAttributionAndTraceability
    -> MaintainAcrossVersions;

Creator :=
    AgentResponsibleForOriginatingOrProducingResource;

CreatedResource MAY_BE {
    Document,
    Dataset,
    Image,
    Audio,
    Video,
    Software,
    Model,
    MetadataRecord,
    Assertion,
    KnowledgeEntity,
    PhysicalWork
};

Creator MAY_BE {
    Person,
    Organisation,
    Institution,
    SoftwareAgent,
    AIModel,
    CollectiveAgent
};

CreatorIdentifier :=
    StableReferenceToCreatorAgent;

CreatorIdentifier MAY_BE {
    URI,
    IRI,
    UUID,
    ORCIDLikeIdentifier,
    OrganisationIdentifier,
    InternalIdentifier
};

StableCreatorIdentifier SHOULD_BE PreferredOverNameOnlyMatching;

CreatorRecord :=
    StructuredMetadataRecordDescribingCreatorIdentityRoleAndAttribution;

CreatorName :=
    HumanReadableNameAssociatedWithCreator;

CreatorName MAY_HAVE {
    PreferredName,
    AlternativeName,
    PreviousName,
    TransliteratedName
};

SameName MAY_REFER_TO DifferentCreators;

DifferentNames MAY_REFER_TO SameCreator;

CreatorIdentityResolution :=
    NameIdentifierAffiliationAndContext
    -> CanonicalCreatorAgent;

CreatorRole :=
    FunctionPerformedByCreatorDuringCreation;

CreatorRole MAY_BE {
    Author,
    Originator,
    Developer,
    Researcher,
    Photographer,
    Composer,
    Designer,
    DataCreator,
    ModelCreator,
    MetadataCreator
};

Author :=
    CreatorResponsibleForAuthoredTextualOrConceptualContent;

Originator :=
    AgentInitiatingOrProducingOriginalResourceOrRecord;

Developer :=
    CreatorResponsibleForSoftwareSystemOrTechnicalArtifact;

Researcher :=
    CreatorResponsibleForResearchActivityOrResearchOutput;

Photographer :=
    CreatorResponsibleForPhotographicImage;

Composer :=
    CreatorResponsibleForMusicalComposition;

Designer :=
    CreatorResponsibleForDesignArtifactOrVisualStructure;

DataCreator :=
    AgentResponsibleForGeneratingOrCompilingDataset;

ModelCreator :=
    AgentOrOrganisationResponsibleForCreatingModelArtifact;

MetadataCreator :=
    AgentResponsibleForCreatingMetadataRecordOrMetadataStatement;

CreatorRole MAY_BE MultipleForSameAgentAndResource;

CreationActivity :=
    ActivityThatGeneratesResource;

CreationActivity MAY_INCLUDE {
    Writing,
    Recording,
    Photographing,
    Designing,
    Programming,
    DataCollection,
    ModelTraining,
    MetadataGeneration
};

Generation :=
    CreationActivity
    -> GENERATES
    -> CreatedResource;

Association :=
    CreationActivity
    -> WAS_ASSOCIATED_WITH
    -> Creator;

IF CreationActivity GENERATES Resource
AND Activity WAS_ASSOCIATED_WITH AgentAsCreator
THEN Resource MAY_BE_ATTRIBUTED_TO Agent;

CreatorAttribution :=
    RelationshipConnectingCreatorToCreatedResource;

Attribution MAY_HAVE {
    Role,
    Scope,
    Order,
    Evidence,
    Confidence
};

CreatorOrder :=
    OrderedPositionOfCreatorWithinAuthorshipOrCreatorList;

CreatorOrder MAY_HAVE DomainSpecificMeaning;

FirstCreator :=
    CreatorAppearingFirstInDefinedCreatorSequence;

CorrespondingCreator :=
    CreatorDesignatedForCommunicationOrResponsibilityAccordingToDomain;

CreatorOrder MUST_NOT AutomaticallyBeInterpretedAsContributionMagnitudeWithoutDomainEvidence;

JointCreation :=
    ResourceCreatedByMultipleCreators;

JointCreator :=
    CreatorParticipatingInJointCreation;

CollectiveCreator :=
    GroupOrganisationOrCollectiveActingAsCreator;

CorporateCreator :=
    OrganisationResponsibleForResourceCreation;

AnonymousCreator :=
    CreatorWhoseIdentityIsNotPubliclySpecifiedOrKnown;

PseudonymousCreator :=
    CreatorRepresentedByPseudonym;

UnknownCreator :=
    CreatorIdentityCannotBeReliablyDetermined;

UnknownCreator != AnonymousCreatorByDefinition;

CreatorAffiliation :=
    OrganisationInstitutionOrGroupAssociatedWithCreatorAtTimeOfCreation;

Affiliation MAY_HAVE {
    Organisation,
    Department,
    Role,
    EffectivePeriod
};

CurrentAffiliation MAY_DIFFER_FROM CreationTimeAffiliation;

CreationTimeAffiliation SHOULD_BE PreservedWhereKnown;

CreatorAuthority :=
    DegreeOrStatusOfRecognisedExpertiseResponsibilityOrInstitutionalAuthority;

CreatorAuthority MAY_BE ContextSpecific;

Creator != OwnerByDefinition;

Creator MAY_NOT HoldCopyrightOwnership;

OwnershipMetadata SHOULD_DISTINGUISH CreatorFromOwner;

CopyrightMetadata MAY_IDENTIFY CreatorAsInitialRightsRelevantAgentAccordingToApplicableContext
BUT CopyrightOwnershipRequiresSeparateDetermination;

Creator != ContributorByDefinition;

Contributor :=
    AgentMakingContributionWithoutNecessarilyBeingPrimaryCreator;

Contribution :=
    ActivityOrInputProvidedByContributor;

ContributorRole MAY_BE {
    Editor,
    Reviewer,
    Translator,
    Curator,
    DataProcessor,
    Illustrator,
    Technician
};

Editor :=
    ContributorResponsibleForEditingOrEditorialWork;

Translator :=
    ContributorResponsibleForTranslation;

Reviewer :=
    ContributorResponsibleForReviewOrEvaluation;

Curator :=
    ContributorResponsibleForSelectionOrganisationOrMaintenance;

CreatorAndContributorRoles MAY_OVERLAP;

RoleSemantics SHOULD_BE ExplicitlyRepresented;

HumanCreator :=
    CreatorThatIsHumanPerson;

OrganisationalCreator :=
    CreatorThatIsOrganisationOrInstitution;

SoftwareCreator :=
    SoftwareAgentGeneratingResourceAccordingToDefinedProcess;

AICreator :=
    AIModelOrAIServiceParticipatingInGenerationOfResourceAccordingToRecordedProvenance;

AIAuthorshipOrLegalCreatorStatus MAY_DIFFER_BY PolicyJurisdictionAndPublicationConvention;

Ontology SHOULD_DISTINGUISH:
    TechnicalGenerationRole
    FROM
    LegalAuthorshipOrOwnershipStatus;

AIModel MAY_GENERATE Resource;

HumanAgent MAY_DIRECTOrEdit AIGeneratedResource;

HybridCreation :=
    ResourceCreatedThroughCombinedHumanAndAutomatedActivities;

HybridCreation SHOULD_PRESERVE {
    HumanAgents,
    SoftwareOrAI agents,
    CreationActivities,
    Roles,
    Provenance
};

CreationTimestamp :=
    TimeAssociatedWithResourceCreation;

CreationDate :=
    CalendarDateAssociatedWithCreation;

CreatedAt :=
    TimestampOfCreationEvent;

CreationTime MAY_BE {
    Exact,
    Approximate,
    Unknown
};

ApproximateCreationDate SHOULD_BE MarkedAsApproximate;

CreatorEvidence :=
    InformationSupportingCreatorAttribution;

Evidence MAY_BE {
    Byline,
    Signature,
    MetadataRecord,
    PublicationRecord,
    SystemLog,
    Contract,
    RepositoryRecord
};

CreatorProvenance MAY_INCLUDE {
    Source,
    Recorder,
    ExtractionMethod,
    VerificationMethod,
    Timestamp,
    Version
};

CreatorConfidence :=
    EstimatedSupportForCreatorIdentityOrAttribution;

Confidence MAY_DEPEND_ON {
    IdentifierStrength,
    EvidenceStrength,
    SourceReliability,
    RoleClarity,
    CrossSourceAgreement
};

CreatorValidation MAY_CHECK {
    CreatorIdentity,
    ResourceIdentity,
    Role,
    CreationActivity,
    Evidence,
    TemporalConsistency
};

IF CreatorIdentifierResolvesToMultipleAgents
THEN CreatorIdentity SHOULD_BE MarkedAmbiguous;

IF CreatorAttributionConflictsAcrossSources
THEN AttributionConflict SHOULD_BE PreservedAndReviewed;

AttributionConflict :=
    MultipleSourcesProvideIncompatibleCreatorClaims;

ConflictHandling MAY {
    PreserveClaims,
    CompareEvidence,
    CompareAuthority,
    AssignConfidence,
    FlagReview
};

CreatorCompleteness :=
    DegreeToWhichRequiredCreatorIdentityRoleAndEvidenceArePresent;

CreatorConsistency :=
    DegreeToWhichCreatorAttributionRoleAndCreationHistoryAgree;

CreatorIntegrity :=
    PreservationOfReliableCreatorIdentityAttributionAndHistory;

CreatorMetadataQuality MAY_INCLUDE {
    Completeness,
    Consistency,
    Integrity,
    IdentityResolution,
    Provenance
};

CreatorVersion :=
    IdentifiedRevisionOfCreatorRecordOrAttribution;

CreatorRecordChange MAY_INCLUDE {
    NameCorrection,
    IdentifierUpdate,
    RoleCorrection,
    AffiliationUpdate,
    AttributionCorrection
};

CreatorIdentity SHOULD_BE PreservedAcrossNameChangesWhereCanonicalIdentifierStable;

CreatorMerge :=
    MultipleCreatorRecords
    -> OneCanonicalCreator;

CreatorSplit :=
    OneAmbiguousCreatorRecord
    -> MultipleDistinctCreators;

MergeOrSplit SHOULD_PRESERVE PreviousIdentifiersAndProvenance;

CreatorHistory :=
    RecordOfIdentityNamesAffiliationsAndAttributionChanges;

DescriptiveMetadata MAY_INCLUDE CreatorAsCoreResourceProperty;

ProvenanceMetadata SHOULD_LINK CreatorToCreationActivityAndResource;

AdministrativeMetadata MAY_DEFINE CreatorRelatedRightsOrResponsibilities;

RightsMetadata MAY_REFERENCE Creator
BUT CreatorRole MUST_NOT AutomaticallyImplyRightsOwnership;

MetadataRepository MAY_STORE CreatorRecordsAndAttributions;

MetadataRegistry MAY_REGISTER CreatorRolesAgentTypesAndIdentityProperties;

KnowledgeGraph MAY_REPRESENT:
    Creator
    -> CREATED
    -> Resource;

Resource
    -> WAS_CREATED_BY
    -> Creator;

CreationActivity
    -> WAS_ASSOCIATED_WITH
    -> Creator;

CreatorGraph SHOULD_PRESERVE {
    Role,
    Activity,
    Time,
    Provenance,
    Confidence
};

RDF MAY_REPRESENT CreatorRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedCreatorMetadata;

Search MAY_USE CreatorMetadataFor {
    CreatorSearch,
    AuthorSearch,
    AffiliationFiltering,
    RoleFiltering
};

SemanticSearch MAY_USE CreatorIdentityAndAuthorityAsContextualSignals;

CreatorAuthority SHOULD_NOT BeUsedAsSoleTruthSignal;

RAG MAY_USE CreatorMetadataFor {
    Attribution,
    SourceContext,
    AuthorityAssessment,
    CitationGeneration
};

RAGOutput SHOULD_PRESERVE CreatorAttributionWhereRelevantAndSupported;

KnowledgeExtraction MAY_IDENTIFY CandidateCreatorFrom {
    Byline,
    Metadata,
    Signature,
    Context
};

AI MAY_SUPPORT {
    CreatorEntityResolution,
    RoleClassification,
    AttributionExtraction,
    DuplicateDetection
};

AIGeneratedCreatorInference SHOULD_BE TreatedAsInferenceUntilValidated;

CreatorMetadata MAY_CONTAIN PersonalInformation;

PrivacyPolicy SHOULD_BE AppliedTo CreatorIdentityAndAffiliationWhereApplicable;

CreatorAccessControl MAY_RESTRICT {
    PersonalIdentifiers,
    ContactInformation,
    SensitiveAffiliations
};

CreatorSecurity MAY_INCLUDE {
    IdentityValidation,
    AccessControl,
    ProvenanceIntegrity,
    ChangeAuthorisation
};

MachineReadableCreator SHOULD_PRESERVE {
    CreatorIdentifier,
    CreatorName,
    AgentType,
    CreatorRole,
    ResourceIdentifier,
    CreationActivity,
    CreationTimestamp,
    Affiliation,
    Evidence,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF AgentIsResponsibleForOriginatingProducingOrGeneratingResource
THEN CreatorClassification := supported;

IF Resource WAS_GENERATED_BY Activity
AND Activity WAS_ASSOCIATED_WITH AgentAsCreator
THEN CreatorAttribution MAY_BE Supported;

IF AgentOnlyEditsReviewsOrTranslatesExistingResource
THEN ContributorRole MAY_BE MoreAppropriateThanPrimaryCreatorRole
according_to context;

IF CreatorIdentifierStableAcrossNameChange
THEN CreatorIdentity SHOULD_REMAIN Continuous;

IF CreatorNameMatchesButIdentifiersConflict
THEN SameCreator MUST_NOT_BE AssumedWithoutResolution;

IF CreatorIsAIModel
THEN TechnicalGenerationRole SHOULD_BE PreservedSeparatelyFromLegalAuthorshipOrOwnership;

IF CreatorAttributionConflicts
THEN AllMaterialClaimsAndProvenance SHOULD_BE PreservedForReview;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "creator" ~= "resource creator" WHEN provenance_context;
    "author" ~= "text creator" WHEN authorship_context;
    "originator" ~= "original creator" WHEN creation_context;
    "creator identifier" ~= "creator ID";
    "creator attribution" ~= "created by relationship";
    "joint creator" ~= "co-creator";
    "corporate creator" ~= "organisational creator";
    "creation activity" ~= "resource generation activity";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_RESOURCE(q) ->
    IDENTIFY_CREATION_ACTIVITY(q) ->
    IDENTIFY_CANDIDATE_CREATORS(q) ->
    RESOLVE_CREATOR_IDENTITIES(q) ->
    IDENTIFY_CREATOR_ROLES(q) ->
    IDENTIFY_CREATOR_ORDER_AND_AFFILIATION(q) ->
    IDENTIFY_CREATION_TIME(q) ->
    IDENTIFY_EVIDENCE_AND_PROVENANCE(q) ->
    DETECT_ATTRIBUTION_CONFLICTS(q) ->
    APPLY_PRIVACY_AND_ACCESS_POLICY(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_CREATOR_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        identifier_strength,
        evidence_strength,
        source_reliability,
        role_clarity,
        temporal_consistency,
        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: Creator;
    ontology: CreatorOntology;
    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;
    distinguish_creator_from_owner: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_creator_attribution:
        identify_resource
        -> identify_creation_activity
        -> resolve_creator_identity
        -> classify_creator_role
        -> attach_creation_time
        -> attach_affiliation
        -> attach_evidence
        -> attach_provenance
        -> validate
        -> assign_confidence
        -> integrate;

    creator_revision:
        preserve_previous_record
        -> apply_identity_name_role_or_affiliation_changes
        -> preserve_canonical_identifier
        -> revalidate_attributions
        -> update_index
        -> recompute_confidence
        -> regenerate_flow_hash;

    creator_merge:
        compare_identifiers_names_affiliations_and_evidence
        -> preserve_source_records
        -> create_canonical_creator
        -> remap_attributions
        -> audit;

    creator_split:
        identify_ambiguous_record
        -> create_distinct_creator_entities
        -> redistribute_attributions
        -> preserve_provenance
        -> audit;

    conflict:
        preserve_all_attribution_claims
        -> compare_sources_evidence_and_identity
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + CreatorEntity
    + AgentEntity
    + ContributionEntity
    + MetadataEntity
    + Creator
    + CreatorAttribution
    + CreatorValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
CreatorOntology
    -> IdentifyCreatedResourceAndCreationActivity
    -> ResolveCanonicalCreatorIdentity
    -> AssignStableCreatorIdentifier
    -> ClassifyCreatorRoleAndAgentType
    -> RecordCreatorOrderAffiliationAndCreationTime
    -> DistinguishCreatorContributorOwnerAndRightsHolderRoles
    -> AttachEvidenceProvenanceAndConfidence
    -> ValidateIdentityRoleAndTemporalConsistency
    -> PreserveHumanSoftwareAndAICreationRelationships
    -> SupportAttributionSearchCitationAndRAGContext
    -> MaintainCreatorIdentityAcrossNamesVersionsAndMerges
    -> ApplyPrivacySecurityAndAccessControls
    -> MaintainReliableCreatorKnowledge;

END FLOW