Licensing Ontology

FLOW ALGEBRA
Licensing Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/metadata-ontologies/administrative-metadata/licensing-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "LicensingOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := AdministrativeMetadata
ONTOLOGY := LicensingOntology

ENTITY Licensing {
    definition:
        "Administrative metadata representing the permissions, restrictions,
         conditions, parties, scope, duration and evidential basis under which
         a resource, right, dataset, software product or other protected asset
         may be accessed, used, copied, modified, distributed or otherwise
         exploited.";
    objectives: [
        LicenceIdentification,
        PermissionManagement,
        RestrictionManagement,
        RightsAdministration,
        UsageControl,
        LicenceLifecycleTracking,
        MachineInterpretability
    ];
}

LicenceEntity := {
    Licence,
    LicenceIdentifier,
    LicenceRecord,
    LicenceStatus,
    LicenceTerm,
    LicenceScope,
    LicenceVersion,
    LicensedResource
};

PartyEntity := {
    Licensor,
    Licensee,
    RightsHolder,
    Agent,
    Organisation,
    Person
};

RightsEntity := {
    Permission,
    Restriction,
    Condition,
    Obligation,
    Prohibition,
    Right,
    UsagePolicy
};

EvidenceEntity := {
    LicenceDocument,
    Agreement,
    Contract,
    Provenance,
    Timestamp,
    Jurisdiction,
    Confidence
};

Licence APPLIES_TO LicensedResource;
Licensor GRANTS Licence;
Licensee RECEIVES Licence;
Licence GRANTS Permission;
Licence MAY_IMPOSE Restriction;
Licence MAY_REQUIRE Obligation;
Licence MAY_DEFINE Prohibition;
LicenceRecord DOCUMENTS Licence;
Provenance SUPPORTS LicenceAssertion;

LicensingFlow :=
    Resource
    -> IdentifyLicensedResource
    -> IdentifyApplicableLicence
    -> AssignLicenceIdentifier
    -> ResolveLicensorAndLicensee
    -> ExtractPermissionsRestrictionsAndConditions
    -> DetermineScopeTerritoryAndDuration
    -> AttachEvidenceAndProvenance
    -> ValidateLicenceMetadata
    -> EvaluateRequestedUse
    -> StoreLicenceRecord
    -> TrackRenewalExpiryAndTermination
    -> MaintainAcrossLifecycle;

LicensedResource :=
    ResourceOrRightSubjectToLicence;

LicensedResource MAY_BE {
    Document,
    Dataset,
    Image,
    Audio,
    Video,
    Software,
    Database,
    Model,
    API,
    DigitalAsset,
    IntellectualProperty
};

Licence :=
    LegalContractualOrPolicyInstrumentGrantingDefinedPermissionsSubjectToConditions;

LicenceIdentifier :=
    StableReferenceToLicenceOrLicenceRecord;

LicenceIdentifier MAY_BE {
    URI,
    IRI,
    UUID,
    ContractNumber,
    LicenceCode,
    InternalIdentifier
};

LicenceRecord :=
    StructuredMetadataRecordDocumentingLicenceTermsAndParties;

LicenceStatement :=
    Licence
    -> APPLIES_TO
    -> LicensedResource;

LicenceStatus :=
    CurrentAdministrativeStateOfLicence;

LicenceStatus MAY_BE {
    Draft,
    Proposed,
    Active,
    Suspended,
    Expired,
    Terminated,
    Superseded,
    Revoked,
    Unknown
};

ActiveLicence :=
    LicenceCurrentlyEffectiveAccordingToRecordedTermsAndConditions;

ExpiredLicence :=
    LicenceWhoseDefinedTermHasEnded;

TerminatedLicence :=
    LicenceEndedBeforeNormalExpiryAccordingToApplicableTerms;

RevokedLicence :=
    LicenceWithdrawnWhereRevocationIsPermittedAndEffective;

SupersededLicence :=
    LicenceReplacedByLaterLicenceOrVersion;

UnknownLicenceStatus :=
    CurrentLicenceStateCannotBeReliablyDetermined;

Licensor :=
    AgentGrantingPermissionsUnderLicence;

Licensee :=
    AgentReceivingPermissionsUnderLicence;

RightsHolder :=
    AgentHoldingRightsNecessaryToGrantRelevantLicence
    OR AgentRepresentedByAuthorisedLicensor;

LicensorAuthority SHOULD_BE VerifiedWhereRequired;

Agent MAY_BE {
    Person,
    Organisation,
    Institution,
    SoftwareService
};

Permission :=
    AuthorisedActionGrantedByLicence;

Permission MAY_INCLUDE {
    Access,
    Use,
    Copy,
    Reproduce,
    Distribute,
    Modify,
    Adapt,
    Translate,
    Display,
    Perform,
    Sublicense,
    CommercialUse
};

Restriction :=
    ConstraintLimitingOtherwisePermittedUse;

Restriction MAY_INCLUDE {
    NonCommercialOnly,
    NoDerivatives,
    TerritoryRestriction,
    UserRestriction,
    PurposeRestriction,
    DistributionRestriction,
    TechnicalRestriction
};

Condition :=
    RequirementThatMustBeSatisfiedForPermissionToApply;

Condition MAY_INCLUDE {
    Attribution,
    NoticeRetention,
    ShareAlike,
    Payment,
    Reporting,
    Registration,
    Compliance
};

Obligation :=
    RequiredActionImposedOnLicensee;

Obligation MAY_BE {
    AttributeCreator,
    PreserveNotice,
    PayFee,
    ReportUsage,
    ShareChanges,
    DeleteAfterTerm
};

Prohibition :=
    ExplicitlyForbiddenAction;

Prohibition MAY_INCLUDE {
    NoRedistribution,
    NoReverseEngineering,
    NoCommercialUse,
    NoModification,
    NoSublicensing
};

Right :=
    UnderlyingLegalContractualOrPolicyEntitlementRelevantToLicence;

LicenceScope :=
    BoundaryWithinWhichLicencePermissionsAndConditionsApply;

LicenceScope MAY_INCLUDE {
    ResourceScope,
    RightScope,
    Territory,
    Purpose,
    Audience,
    Medium,
    Platform,
    UserCount
};

ResourceScope :=
    ResourceOrSetOfResourcesCoveredByLicence;

RightScope :=
    RightsOrActionsCoveredByLicence;

Territory :=
    GeographicOrLegalAreaWhereLicenceApplies;

Purpose :=
    PermittedPurposeOrUseCase;

Audience :=
    PermittedUserGroupOrClass;

LicenceTerm :=
    TemporalPeriodDuringWhichLicenceIsEffective;

LicenceTerm MAY_HAVE {
    StartDate,
    EndDate,
    RenewalDate,
    TerminationDate
};

PerpetualLicence :=
    LicenceWithoutDefinedExpirySubjectToApplicableTerminationConditions;

FixedTermLicence :=
    LicenceWithDefinedStartAndEnd;

SubscriptionLicence :=
    LicenceEffectiveDuringRecurringPaidOrContractualPeriod;

TrialLicence :=
    TimeOrFeatureLimitedLicenceForEvaluation;

LicenceRenewal :=
    ExtensionOrReplacementOfLicenceTerm;

Renewal MAY_BE {
    Automatic,
    Manual,
    Conditional
};

RenewalCondition MAY_INCLUDE {
    Payment,
    Notice,
    Compliance,
    Agreement
};

LicenceExpiry :=
    EndOfLicenceTermWithoutEffectiveRenewal;

IF CurrentTime > LicenceEndDate
AND NoRenewalApplies
THEN LicenceStatus MAY_BE Expired;

Termination :=
    EventEndingLicenceBeforeOrAtDefinedTermAccordingToTerms;

Termination MAY_HAVE {
    Initiator,
    EffectiveDate,
    Reason,
    NoticePeriod
};

Suspension :=
    TemporaryDisablingOfLicencePermissions;

Revocation :=
    WithdrawalOfLicenceWhereLegallyOrContractuallyPermitted;

LicenceVersion :=
    IdentifiedRevisionOfLicenceTermsOrMetadata;

LicenceHistory :=
    OrderedRecordOfLicenceVersionsRenewalsSuspensionsAndTerminations;

LicenceHistory SHOULD_PRESERVE {
    PreviousVersion,
    EffectivePeriod,
    Parties,
    Terms,
    Provenance
};

LicenceChange MAY_INCLUDE {
    PermissionChange,
    RestrictionChange,
    PartyChange,
    TerritoryChange,
    TermChange,
    FeeChange,
    VersionChange
};

MaterialLicenceChange :=
    ChangeThatAltersPermittedOrProhibitedUse;

MaterialLicenceChange SHOULD_BE VersionedAndAudited;

LicenceDocument :=
    AuthoritativeOrSupportingDocumentContainingLicenceTerms;

Agreement :=
    ContractualRecordSupportingLicenceRelationship;

LicenceEvidence :=
    InformationSupportingLicenceExistenceTermsAuthorityOrStatus;

Evidence MAY_BE {
    LicenceDocument,
    Agreement,
    Contract,
    RightsStatement,
    TransactionRecord,
    AuthorityRecord
};

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

LicenceConfidence :=
    EstimatedSupportForLicenceMetadataAssertion;

Confidence MAY_DEPEND_ON {
    EvidenceStrength,
    PartyIdentity,
    TermClarity,
    SourceReliability,
    ConflictStatus
};

LicenceValidation MAY_CHECK {
    ResourceIdentity,
    LicensorIdentity,
    LicenseeIdentity,
    LicensorAuthority,
    TermDates,
    PermissionConsistency,
    RestrictionConsistency,
    Evidence
};

IF LicenceEndDate < LicenceStartDate
THEN TemporalValidation := violation;

IF LicenceGrantsAndProhibitsSameActionInSameScopeWithoutPrecedenceRule
THEN LicenceConflict SHOULD_BE Flagged;

LicenceConflict :=
    IncompatibleLicenceTermsOrOverlappingLicenceAssertions;

ConflictHandling MAY {
    PreserveTerms,
    ApplyPrecedenceRules,
    CompareAuthority,
    AssignConfidence,
    FlagReview
};

LicenceRecord SHOULD_NOT SilentlyDiscard ConflictingTerms;

LicenceCompleteness :=
    DegreeToWhichRequiredLicenceMetadataIsPresent;

LicenceConsistency :=
    DegreeToWhichPermissionsRestrictionsConditionsAndTermDoNotConflict;

LicenceIntegrity :=
    PreservationOfReliableLicenceRecordsEvidenceAndHistory;

LicenceMetadataQuality MAY_INCLUDE {
    Completeness,
    Consistency,
    Integrity,
    Timeliness,
    Provenance
};

UsageRequest :=
    RequestedActionByAgentOnLicensedResource;

UsageRequest MAY_INCLUDE {
    Action,
    Resource,
    RequestingAgent,
    Purpose,
    Territory,
    Time,
    Audience
};

LicenceEvaluation :=
    UsageRequest
    + ActiveLicence
    + Permissions
    + Restrictions
    + Conditions
    -> Decision;

LicenceDecision MAY_BE {
    Permitted,
    Denied,
    Conditional,
    ReviewRequired
};

IF RequestedActionNotGranted
THEN Decision SHOULD_NOT_BE PermittedWithoutOtherValidAuthority;

IF RequestedActionExplicitlyProhibited
THEN Decision := Denied
UNLESS HigherPriorityLegalOrPolicyRuleApplies;

IF PermissionRequiresCondition
AND ConditionNotSatisfied
THEN Decision MAY_BE ConditionalOrDenied;

LicenceEvaluation SHOULD_PRESERVE DecisionBasis;

AttributionCondition :=
    RequirementToCreditSpecifiedCreatorRightsHolderOrSource;

AttributionMetadata MAY_INCLUDE {
    Name,
    Identifier,
    RequiredText,
    Link
};

ShareAlikeCondition :=
    RequirementThatDerivativeOrRedistributedWorkUseSpecifiedCompatibleTerms;

Compatibility :=
    RelationshipBetweenLicencesForCombinedDerivativeOrRedistributedResources;

LicenceCompatibility MAY_REQUIRE LegalOrPolicyAnalysisBeyondSimpleMetadataMatching;

Sublicence :=
    LicenceGrantedByLicenseeToThirdPartyWhereOriginalLicencePermits;

Sublicence MUST_NOT ExceedAuthorityGrantedByParentLicence;

ParentLicence :=
    LicenceAuthorisingSublicensing;

ChildLicence :=
    SublicenceDerivedFromParentLicence;

IF ParentLicenceTerminates
THEN ChildLicenceEffect MAY_REQUIRE EvaluationAccordingToTerms;

OpenLicence :=
    LicenceProvidingBroadReusePermissionsSubjectToDefinedConditions;

ProprietaryLicence :=
    LicenceProvidingUseRightsUnderMoreRestrictedOrNegotiatedTerms;

PublicDomainDedication :=
    InstrumentIntendedTo WaiveOrDedicateRightsWhereLegallyPossible;

PublicDomainStatus != LicenceByDefinition;

NoLicence :=
    AbsenceOfIdentifiedLicence;

NoLicence DOES_NOT Mean NoRightsOrUnrestrictedUse;

UnknownLicence :=
    ApplicableLicenceCannotBeReliablyDetermined;

AdministrativeMetadata MAY_USE LicensingAsRightsManagementComponent;

CopyrightMetadata MAY_DEFINE UnderlyingRightsRelevantToLicence;

OwnershipMetadata MAY_IDENTIFY OwnerButOwnerMayNotHoldAllLicensableRights;

ProvenanceMetadata MAY_RECORD LicenceSourceChangesAndAssignments;

AccessPolicy MAY_BE DerivedPartlyFromLicenceTerms;

MetadataRepository MAY_STORE LicenceRecords;

MetadataRegistry MAY_REGISTER LicenceTypesPermissionsRestrictionsAndConditions;

KnowledgeGraph MAY_REPRESENT:
    Licensor
    -> GRANTS
    -> Licence;

Licence
    -> APPLIES_TO
    -> LicensedResource;

Licence
    -> GRANTS_PERMISSION
    -> Permission;

LicenceGraph SHOULD_PRESERVE {
    Parties,
    Scope,
    Term,
    Conditions,
    Provenance
};

RDF MAY_REPRESENT LicenceRelationshipsAsTypedStatements;

JSONLD MAY_SERIALISE LinkedLicensingMetadata;

Search MAY_USE LicensingMetadataFor {
    ReuseFiltering,
    CommercialUseFiltering,
    ModificationFiltering,
    LicenceTypeFiltering
};

SemanticSearch SHOULD_APPLY LicenceAndAccessRulesBeforeReturningProtectedContentForRestrictedUse;

RAG MAY_USE LicensingMetadataFor {
    SourceEligibility,
    ReusePolicy,
    AttributionRequirements,
    DistributionConstraints
};

AI MAY_SUPPORT {
    LicenceExtraction,
    ClauseClassification,
    PermissionDetection,
    RestrictionDetection,
    ConflictDetection
};

AIGeneratedLicenceInterpretation SHOULD_NOT BeTreatedAsAuthoritativeLegalDeterminationWithoutAppropriateValidation;

LicensingMetadata MAY_CONTAIN ConfidentialCommercialTerms;

PrivacyAndConfidentialityPolicy SHOULD_BE AppliedWhereApplicable;

LicenceAccessControl MAY_APPLY_TO {
    ContractTerms,
    Fees,
    PartyDetails,
    Evidence
};

LicensingSecurity MAY_INCLUDE {
    PartyIdentityValidation,
    AccessControl,
    EvidenceIntegrity,
    Audit,
    ChangeAuthorisation
};

MachineReadableLicence SHOULD_PRESERVE {
    LicenceIdentifier,
    LicensedResourceIdentifier,
    LicensorIdentifier,
    LicenseeIdentifier,
    Permissions,
    Restrictions,
    Conditions,
    Scope,
    Territory,
    Term,
    Status,
    Evidence,
    Provenance,
    Confidence
};

# ---------- SEMANTIC REASONING ----------
IF AdministrativeMetadataDefinesPermissionsRestrictionsOrConditionsForResourceUse
THEN LicensingClassification := supported;

IF LicenceStatusNotActive
THEN Permissions SHOULD_NOT AutomaticallyBeTreatedAsCurrentlyEffective;

IF LicenceGrantsAction
AND AllRequiredConditionsSatisfied
AND NoApplicableProhibitionOverrides
THEN RequestedAction MAY_BE PermittedWithinScope;

IF LicenceDoesNotMentionAction
THEN Permission MUST_NOT_BE InferredWithoutOtherValidAuthority;

IF LicenceExpired
THEN CurrentUse SHOULD_BE ReassessedAccordingToTermsAndOtherRights;

IF LicensorLacksAuthorityForRight
THEN LicencePermissionConfidence SHOULD_DECREASE
AND Review SHOULD_BE Triggered;

IF SublicenceExceedsParentLicenceScope
THEN SublicenceValidation := violation;

IF LicenceVersionChangesMaterialTerms
THEN UsageDecisions SHOULD_BE RecomputedForAffectedResources;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "licensing metadata" ~= "licence metadata";
    "license metadata" ~= "licence metadata";
    "licensor" ~= "licence grantor";
    "licensee" ~= "licence recipient";
    "licence term" ~= "licence duration";
    "licence scope" ~= "licensed use scope";
    "licence restriction" ~= "licensing restriction";
    "licence condition" ~= "condition of use";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_LICENSED_RESOURCE(q) ->
    IDENTIFY_LICENCE_RECORD(q) ->
    RESOLVE_LICENCE_IDENTIFIER(q) ->
    RESOLVE_LICENSOR_AND_LICENSEE(q) ->
    IDENTIFY_PERMISSIONS_RESTRICTIONS_CONDITIONS(q) ->
    IDENTIFY_SCOPE_TERRITORY_AND_TERM(q) ->
    IDENTIFY_STATUS_VERSION_AND_HISTORY(q) ->
    IDENTIFY_EVIDENCE_AND_PROVENANCE(q) ->
    EVALUATE_REQUESTED_USE(q) ->
    VALIDATE_LICENCE_METADATA(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_AUTHORISED_LICENSING_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        evidence_strength,
        source_reliability,
        party_identity_strength,
        term_clarity,
        licence_consistency,
        provenance_quality,
        conflict_status
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: Licensing;
    ontology: LicensingOntology;
    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;
    enforce_licence_policy: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_licence:
        identify_resource
        -> assign_licence_identifier
        -> resolve_licensor_and_licensee
        -> extract_permissions_restrictions_and_conditions
        -> define_scope_territory_and_term
        -> attach_evidence
        -> attach_provenance
        -> validate
        -> assign_confidence
        -> integrate;

    licence_revision:
        preserve_previous_version
        -> apply_authorised_term_changes
        -> classify_material_changes
        -> revalidate_permissions_and_restrictions
        -> audit_change
        -> recompute_usage_decisions
        -> regenerate_flow_hash;

    renewal_or_termination:
        identify_active_licence
        -> validate_event
        -> update_term_and_status
        -> preserve_history
        -> revalidate_permissions
        -> integrate;

    conflict:
        preserve_all_terms_and_evidence
        -> apply_precedence_rules
        -> compare_authority_and_scope
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + LicenceEntity
    + PartyEntity
    + RightsEntity
    + EvidenceEntity
    + Licensing
    + LicenceEvaluation
    + LicenceValidation
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
LicensingOntology
    -> IdentifyLicensedResource
    -> AssignStableLicenceIdentifier
    -> ResolveLicensorLicenseeAndAuthority
    -> ExtractPermissionsRestrictionsConditionsAndObligations
    -> DefineResourceScopeTerritoryPurposeAndAudience
    -> RecordLicenceTermStatusRenewalAndTermination
    -> AttachAuthoritativeEvidenceProvenanceAndConfidence
    -> ValidateConflictingTermsAndTemporalConsistency
    -> EvaluateRequestedUsesAgainstLicenceRules
    -> PreserveLicenceVersionsAndLifecycleHistory
    -> ApplyAccessReuseAttributionAndDistributionControls
    -> SupportAuthorisedSearchRAGAndMachineConsumption
    -> MaintainReliableLicensingKnowledge;

END FLOW