Trust Ontology

FLOW ALGEBRA
Trust Ontology
Kireth Semantic Research Archive

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

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "TrustOntology" v4.0

DOMAIN := MetadataOntologies
SUBDOMAIN := ProvenanceMetadata
ONTOLOGY := TrustOntology

ENTITY Trust {
 definition: "A contextual, evidence-based assessment of the degree to which a resource, source, agent, assertion, process, model or metadata object may be relied upon for a defined purpose, based on provenance, authority, integrity, validation, consistency, transparency and uncertainty.";
 objectives: [TrustAssessment, EvidenceEvaluation, SourceReliability, ProvenanceReasoning, IntegrityAssessment, UncertaintyRepresentation, MachineInterpretability];
}

TrustEntity := {Trust, TrustAssessment, TrustSignal, TrustScore, TrustLevel, TrustContext, TrustRecord, TrustIdentifier};
EvidenceEntity := {Evidence, Provenance, Source, Validation, Audit, Signature, Fixity, Citation};
AgentEntity := {Agent, Authority, Creator, Publisher, Organisation, SoftwareAgent, AIModel};
QualityEntity := {Reliability, Credibility, Integrity, Authenticity, Transparency, Consistency, Confidence, Reputation};

TrustAssessment EVALUATES TrustSubject;
TrustAssessment USES Evidence;
Provenance SUPPORTS TrustAssessment;
Authority MAY_INCREASE TrustSignal;
Integrity SUPPORTS Trustworthiness;
Validation PRODUCES TrustEvidence;
TrustSignal CONTRIBUTES_TO TrustScore;
TrustScore MAY_MAP_TO TrustLevel;

TrustFlow :=
 TrustSubject
 -> IdentifyTrustContext
 -> ResolveSubjectIdentityAndVersion
 -> GatherProvenanceAndEvidence
 -> AssessSourceAndAgentAuthority
 -> AssessIntegrityAuthenticityAndValidation
 -> AssessConsistencyTransparencyAndCurrency
 -> IdentifyConflictsUncertaintyAndMissingEvidence
 -> ComputeContextualTrustSignals
 -> DeriveTrustAssessment
 -> AttachProvenanceAndConfidence
 -> StoreTrustRecord
 -> MaintainAcrossLifecycle;

TrustSubject MAY_BE {Source, Resource, Agent, Assertion, Dataset, Publication, Software, Model, MetadataRecord, KnowledgeGraphStatement};

Trust := ContextDependentRelianceAssessment;
Trust != TruthByDefinition;
Trust != CertaintyByDefinition;
Trust != AuthorityByDefinition;
Trust != ReputationByDefinition;

TrustIdentifier := StableReferenceToTrustAssessmentOrRecord;
TrustIdentifier MAY_BE {URI, IRI, UUID, InternalIdentifier};

TrustRecord := StructuredMetadataRecordPreservingTrustAssessmentInputsOutputsAndProvenance;

TrustContext := PurposeEnvironmentDomainAndDecisionForWhichTrustIsAssessed;
TrustContext MAY_INCLUDE {Domain, Task, UserNeed, RiskLevel, Time, Jurisdiction, Application};

SameSubject MAY_HAVE DifferentTrustAssessmentsAcrossContexts;

TrustAssessment := EvaluationOfTrustSubjectAgainstDefinedEvidenceCriteria;
TrustAssessment SHOULD_PRESERVE {SubjectIdentifier, SubjectVersion, Context, Evidence, Method, Timestamp, Result};

TrustSignal := IndividualEvidenceBasedIndicatorRelevantToTrust;
TrustSignal MAY_BE {AuthoritySignal, ProvenanceSignal, IntegritySignal, ValidationSignal, ConsistencySignal, TransparencySignal, CurrencySignal, IndependenceSignal};

PositiveTrustSignal := SignalIncreasingSupportForReliance;
NegativeTrustSignal := SignalReducingSupportForReliance;
UnknownSignal := SignalCannotBeReliablyEvaluated;

AbsenceOfNegativeEvidence != PositiveEvidenceByDefinition;

TrustScore := NumericOrOrdinalAggregationOfTrustSignals;
TrustScore MAY_BE {ProbabilityLikeScore, WeightedScore, OrdinalScore, CustomScore};

TrustScore MUST_HAVE DefinedScaleAndMethod;
TrustScore SHOULD_NOT BePresentedAsObjectiveTruthWithoutMethodContext;

TrustLevel MAY_BE {High, Moderate, Low, Unknown, ReviewRequired};

TrustThreshold := ContextSpecificBoundaryMappingTrustScoreToDecisionOrLevel;
HighRiskContext MAY_REQUIRE HigherTrustThreshold;

Evidence := InformationSupportingOrChallengingTrustAssessment;
Evidence MAY_BE {PrimarySource, AuditRecord, ValidationResult, DigitalSignature, Checksum, Citation, IndependentConfirmation, AuthorityRecord};

EvidenceStrength := DegreeToWhichEvidenceSupportsTrustSignal;
EvidenceQuality MAY_INCLUDE {Relevance, Reliability, Independence, Currency, Integrity};

Provenance := OriginDerivationActivityAgentAndHistoryInformation;
ProvenanceCompleteness MAY_SUPPORT TrustAssessment;
MissingProvenance MAY_DECREASE TrustConfidence;
CompleteProvenance DOES_NOT GuaranteeTruth;

SourceReliability := EstimatedDependabilityOfSourceForDefinedPurpose;
SourceReliability MAY_DEPEND_ON {HistoricalAccuracy, Provenance, EditorialControls, EvidenceQuality, Independence};

Credibility := PerceivedOrEvidenceBasedBelievabilityOfSourceAgentOrAssertion;
Credibility SHOULD_BE GroundedInEvidenceWhereUsedComputationally;

Authority := RecognisedExpertiseOfficialStatusOrResponsibilityWithinDefinedScope;
AuthorityIsContextSpecific := true;

IF AgentIsAuthoritativeInDomainA
THEN Authority MUST_NOT AutomaticallyTransferToUnrelatedDomainB;

Reputation := HistoricalOrCommunityAssessmentOfAgentOrSource;
Reputation MAY_BE TrustSignal;
Reputation MUST_NOT OverrideDirectContradictoryEvidence;

Integrity := DegreeToWhichResourceOrRecordIsCompleteAndUnalteredExceptForDocumentedChanges;
Fixity := EvidenceThatDigitalResourceHasNotChangedUnexpectedly;
Checksum := ComputedDigestUsedForIntegrityVerification;

IF CurrentChecksum != RecordedChecksum
THEN IntegritySignal SHOULD_DECREASE;

Authenticity := DegreeToWhichResourceCanBeTrustedAsWhatItPurportsToBe;
AuthenticityEvidence MAY_INCLUDE {Signature, Provenance, CustodyHistory, AuthorityRecord};

DigitalSignature MAY_SUPPORT {Integrity, Authentication, NonRepudiation} according_to cryptographic_context;

Validation := ProcessAssessingSubjectAgainstRulesEvidenceOrExpectedProperties;
ValidationStatus MAY_BE {Validated, PartiallyValidated, Failed, NotValidated, Unknown};

ValidationSuccess MAY_INCREASE TrustSignal;
ValidationFailure MAY_DECREASE TrustSignal;
ValidationScope MUST_BE Preserved;

Consistency := DegreeToWhichClaimsMetadataOrEvidenceAgreeInternallyAndExternally;
InternalConsistency := AgreementWithinResourceOrRecord;
ExternalConsistency := AgreementWithIndependentEvidenceOrAuthoritativeReference;

ConsistencyWithMultipleCopiedSources SHOULD_NOT BeTreatedAsIndependentCorroboration;

Independence := DegreeToWhichEvidenceSourcesDoNotShareSameUnderlyingOrigin;
CommonAncestorSource MAY_REDUCE ApparentEvidenceIndependence;

Transparency := DegreeToWhichMethodsSourcesLimitationsAndDecisionBasisAreVisible;
Transparency MAY_SUPPORT AuditabilityAndTrustAssessment;
Transparency DOES_NOT GuaranteeCorrectness;

Explainability := AbilityToProvideReasonForTrustAssessment;
TrustAssessment SHOULD_PRESERVE MajorSignalsAndDecisionBasisWherePossible;

Currency := AppropriatenessOfInformationAgeForDefinedContext;
Freshness := RecencyOfSourceOrEvidence;
FreshnessRequirement IS_CONTEXT_DEPENDENT;

HistoricalSource MAY_BE HighlyTrustworthyForHistoricalClaimDespiteLowRecency;

Completeness := DegreeToWhichRequiredInformationOrEvidenceIsPresent;
MissingCriticalEvidence SHOULD_DECREASE TrustConfidence;

Uncertainty := DegreeOfUnknownAmbiguityOrIncompleteSupport;
Uncertainty MAY_BE {Aleatoric, Epistemic, Measurement, Source, Model, Resolution};

TrustConfidence := ConfidenceInTrustAssessmentItself;
TrustConfidence != TrustScoreByDefinition;

HighTrustScoreWithLowAssessmentConfidence SHOULD_BE RepresentedExplicitly;

Conflict := IncompatibleEvidenceClaimsOrTrustSignals;
TrustConflict MAY_INCLUDE {SourceConflict, ProvenanceConflict, ValidationConflict, AuthorityConflict};

ConflictHandling MAY {PreserveEvidence, CompareIndependence, CompareAuthority, CompareCurrency, WeightEvidence, FlagReview};

TrustAssessment SHOULD_NOT SilentlyDiscard ContradictoryEvidence;

Corroboration := IndependentEvidenceSupportingSameAssertionOrResourceState;
IndependentCorroboration MAY_INCREASE TrustSignal;
CopiedOrDerivedEvidence SHOULD_NOT CountAsFullyIndependentCorroboration;

Contradiction := EvidenceInconsistentWithAssertionOrSource;
Contradiction SHOULD_BE PreservedAndEvaluated;

TrustDecay := ReductionInTrustApplicabilityOverTimeWhenEvidenceBecomesStaleOrContextChanges;
TrustDecay MAY_APPLY_TO {Credentials, Certifications, DynamicData, ModelEvaluations, SecurityState};

TrustReassessmentTrigger MAY_INCLUDE {NewEvidence, SourceRevision, VersionChange, Retraction, SecurityIncident, PolicyChange, TimeExpiry};

VersionSpecificTrust := TrustAssessmentBoundToExactResourceVersion;
Trust SHOULD_NOT AutomaticallyTransferAcrossMaterialVersionChanges;

IF ResourceVersionChangesMaterially
THEN TrustAssessment MAY_REQUIRE Recalculation;

SourceOntology MAY_PROVIDE SourceIdentityAuthorityReliabilityAndVersion;
ProvenanceOntology MAY_PROVIDE OriginActivityAgentAndEvidenceHistory;
LineageOntology MAY_PROVIDE UpstreamSourcesAndTransformationPaths;
VersionOntology MAY_PROVIDE ExactResourceState;
RevisionHistoryOntology MAY_EXPLAIN ChangesAffectingTrust;
CitationOntology MAY_PROVIDE EvidenceRelationships;
PublicationOntology MAY_PROVIDE PublisherVersionAndIntegrityStatus;
CreatorAuthorContributorOntologies MAY_PROVIDE AgentAttribution;

RetractionStatus := PublicationOrResourceIntegritySignal;
IF SourceRetracted
THEN TrustSignal SHOULD_DECREASEForClaimsDependingOnRetractedContent;

Correction MAY_REQUIRE ReassessmentRatherThanAutomaticDistrust;

Audit := IndependentOrControlledAssessmentOfProcessResourceOrSystem;
AuditResult MAY_BE TrustEvidence;

Certification := ExternalAttestationAgainstDefinedStandard;
Certification MAY_BE TrustSignal;
CertificationScopeAndValidityPeriod MUST_BE Preserved;

TrustPolicy := RulesDefiningTrustAssessmentMethodThresholdsAndPermittedUses;
TrustPolicy MAY_DIFFER_BY ApplicationAndRisk;

TrustDecision := DecisionUsingTrustAssessment;
TrustDecision MAY_BE {Accept, AcceptWithCaution, RequireReview, RejectForPurpose};

TrustDecision SHOULD_REFERENCE ContextAndPolicy;
LowTrust DOES_NOT NecessarilyMeanFalse;
HighTrust DOES_NOT NecessarilyMeanTrue;

HumanTrustAssessment := TrustAssessmentPerformedByHumanReviewer;
AutomatedTrustAssessment := TrustAssessmentPerformedBySystem;
HybridTrustAssessment := CombinationOfHumanAndAutomatedEvaluation;

AI MAY_SUPPORT {EvidenceAggregation, SourceAssessment, ConflictDetection, AnomalyDetection, TrustSignalCalculation};

AIGeneratedTrustAssessment SHOULD_HAVE {ModelOrMethod, Evidence, Confidence, Provenance, Limitations};

AI SHOULD_NOT FabricateEvidenceAuthorityOrValidationResults;

ModelTrust MAY_INCLUDE {EvaluationQuality, DataProvenance, Robustness, Monitoring, Version, KnownLimitations};

AIModelTrust SHOULD_BE TaskAndVersionSpecific;

KnowledgeGraph MAY_REPRESENT:
 TrustAssessment -> EVALUATES -> TrustSubject;
 TrustAssessment -> USES_EVIDENCE -> Evidence;
 TrustAssessment -> PRODUCES -> TrustSignal;

TrustGraph SHOULD_PRESERVE {Context, Evidence, Direction, Method, Timestamp, Version, Provenance};

RDF MAY_REPRESENT TrustRelationshipsAsTypedStatements;
JSONLD MAY_SERIALISE LinkedTrustMetadata;

Search MAY_USE TrustMetadataFor {SourceFiltering, EvidenceRanking, AuthorityFiltering, ReviewPrioritisation};
SemanticSearch MAY_USE TrustSignalsAsRankingFeatures;
Ranking MUST_NOT HideLowTrustEvidenceWhenContradictionIsMaterialToUserQuery;

RAG MAY_USE TrustMetadataFor {SourceSelection, EvidenceWeighting, ConflictResolution, CitationPrioritisation};
RAG SHOULD_PRESERVE ContradictoryEvidenceWhenMaterial;
TrustAwareRAG SHOULD_PRESERVE {SourceIdentifier, SourceVersion, TrustContext, TrustSignals, Provenance};

MetadataRepository MAY_STORE TrustRecordsAndEvidenceLinks;
MetadataRegistry MAY_REGISTER TrustSignalsLevelsMethodsAndPolicies;

TrustMetadata MAY_CONTAIN SensitiveReputationalSecurityOrPersonalInformation;
AccessControlAndPrivacyPolicy SHOULD_BE AppliedToTrustRecords;

TrustSecurity MAY_INCLUDE {EvidenceIntegrity, AssessmentIntegrity, AccessControl, Audit, ChangeAuthorisation};

MachineReadableTrust SHOULD_PRESERVE {
 TrustIdentifier,
 TrustSubjectIdentifier,
 TrustSubjectVersion,
 TrustContext,
 TrustSignals,
 TrustScore,
 TrustLevel,
 TrustConfidence,
 Evidence,
 Method,
 Timestamp,
 Provenance
};

# ---------- SEMANTIC REASONING ----------
IF AssessmentEvaluatesReliabilityOfSubjectForDefinedPurposeUsingEvidence
THEN TrustClassification := supported;

IF SourceIsAuthoritative
THEN AuthoritySignal MAY_INCREASE
BUT Truth MUST_NOT_BE AutomaticallyInferred;

IF MultipleSourcesAgree
AND SourcesAreIndependent
THEN CorroborationSignal MAY_INCREASE;

IF MultipleSourcesAgree
BUT ShareCommonAncestor
THEN IndependenceSignal SHOULD_NOT IncreaseAsIfIndependent;

IF IntegrityCheckFails
THEN IntegrityTrustSignal SHOULD_DECREASE;

IF CriticalProvenanceMissing
THEN TrustConfidence SHOULD_DECREASE;

IF MaterialVersionChangeOccurs
THEN PreviousTrustAssessment SHOULD_NOT AutomaticallyApplyToNewVersion;

IF EvidenceConflicts
THEN Conflict SHOULD_BE PreservedAndTrustAssessment SHOULD_REFLECT Uncertainty;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
 "trust" ~= "contextual trustworthiness" WHEN provenance_context;
 "trust assessment" ~= "trustworthiness assessment";
 "trust signal" ~= "trust indicator";
 "source reliability" ~= "source dependability";
 "credibility" ~= "evidence-based believability" WHEN trust_context;
 "trust score" ~= "trustworthiness score";
 "trust confidence" ~= "confidence in trust assessment";
 "independent corroboration" ~= "independent supporting evidence";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
 NORMALISE(q) ->
 IDENTIFY_TRUST_SUBJECT(q) ->
 RESOLVE_SUBJECT_IDENTITY_AND_VERSION(q) ->
 IDENTIFY_TRUST_CONTEXT_AND_POLICY(q) ->
 GATHER_PROVENANCE_SOURCES_AND_EVIDENCE(q) ->
 ASSESS_AUTHORITY_RELIABILITY_AND_INDEPENDENCE(q) ->
 ASSESS_INTEGRITY_AUTHENTICITY_AND_VALIDATION(q) ->
 ASSESS_CONSISTENCY_TRANSPARENCY_CURRENCY_AND_COMPLETENESS(q) ->
 IDENTIFY_CONFLICTS_AND_UNCERTAINTY(q) ->
 COMPUTE_TRUST_SIGNALS_AND_SCORE(q) ->
 DERIVE_TRUST_LEVEL_AND_CONFIDENCE(q) ->
 APPLY_ACCESS_AND_PRIVACY_POLICY(q) ->
 RETURN_CONTEXTUAL_TRUST_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
 weighted_mean(
  evidence_strength,
  provenance_quality,
  assessment_method_quality,
  subject_identity_strength,
  contextual_relevance,
  conflict_resolution_strength
 );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
 primary_entity: Trust;
 ontology: TrustOntology;
 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_trust_from_truth: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
 new_trust_assessment:
  identify_subject_and_version
  -> define_context_and_policy
  -> gather_evidence
  -> compute_trust_signals
  -> identify_conflicts_and_uncertainty
  -> calculate_score
  -> derive_level
  -> attach_assessment_confidence
  -> attach_provenance
  -> validate
  -> integrate;

 new_evidence:
  identify_affected_trust_assessments
  -> classify_supporting_or_contradictory_evidence
  -> reassess_independence_and_authority
  -> recompute_signals_score_and_confidence
  -> preserve_previous_assessment
  -> integrate;

 subject_revision:
  preserve_previous_subject_version
  -> identify_material_changes
  -> invalidate_or_reassess_version_specific_trust
  -> regenerate_flow_hash;

 conflict:
  preserve_all_material_evidence
  -> identify_common_ancestry
  -> compare_authority_integrity_currency_and_independence
  -> adjust_trust_and_confidence
  -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
 DOMAIN
 + SUBDOMAIN
 + ONTOLOGY
 + TrustEntity
 + EvidenceEntity
 + AgentEntity
 + QualityEntity
 + Trust
 + TrustAssessment
 + TrustSignal
 + RELATIONSHIPS
 + SEMANTIC_REASONING
 + SEMANTIC_EQUIVALENCE
 + UPDATE_MODEL;

FLOW_HASH := HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
TrustOntology
 -> IdentifyTrustSubjectExactVersionAndContext
 -> GatherSourcesProvenanceValidationAndEvidence
 -> AssessAuthorityReliabilityIntegrityAuthenticityAndTransparency
 -> DistinguishIndependentCorroborationFromCopiedEvidence
 -> PreserveContradictionsMissingEvidenceAndUncertainty
 -> ComputeExplainableContextualTrustSignals
 -> DeriveTrustScoreLevelAndAssessmentConfidence
 -> KeepTrustSeparateFromTruthCertaintyAndReputation
 -> ReassessTrustAfterMaterialVersionEvidenceOrPolicyChanges
 -> SupportTrustAwareSearchRAGAndKnowledgeReasoning
 -> PreserveEvidenceMethodTimestampAndProvenance
 -> ApplyPrivacySecurityAndAccessControls
 -> MaintainReliableContextualTrustKnowledge;

END FLOW