AI Risk Ontology documentation

This is an automatic generated API reference of the main components of AI Atlas Nexus

AIComponent

Bases: Entity

Component (element) of an AI system

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIComponent(Entity):
    """
    Component (element) of an AI system
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AIComponent',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AIDeployer

Bases: AIOperator

Any natural or legal person, public authority, agency or other body using an AI system under its authority except where the AI system is used in the course of a personal non-professional activity.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIDeployer(AIOperator):
    """
    Any natural or legal person, public authority, agency or other body using an AI system under its authority except where the AI system is used in the course of a personal non-professional activity.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AIDeployer',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a stakeholder is part of a stakeholder group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AIDeveloper

Bases: Stakeholder

An organisation or entity that is concerned with the development of AI services and products.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIDeveloper(Stakeholder):
    """
    An organisation or entity that is concerned with the development of AI services and products.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AIDeveloper',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a stakeholder is part of a stakeholder group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AIOperator

Bases: Stakeholder

Refers to a provider, product manufacturer, deployer, authorised representative, importer or distributor.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIOperator(Stakeholder):
    """
    Refers to a provider, product manufacturer, deployer, authorised representative, importer or distributor.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AIOperator',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a stakeholder is part of a stakeholder group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AISubject

Bases: Stakeholder

An entity that is subject to or impacted by the use of AI.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AISubject(Stakeholder):
    """
    An entity that is subject to or impacted by the use of AI.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AISubject',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a stakeholder is part of a stakeholder group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AIUC1ApplicationCategory

Bases: str, Enum

AIUC1 Application Category

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIUC1ApplicationCategory(str, Enum):
    """
    AIUC1 Application Category
    """
    MANDATORY = "MANDATORY"
    """
    Mandatory
    """
    OPTIONAL = "OPTIONAL"
    """
    Optional
    """

MANDATORY = 'MANDATORY' class-attribute instance-attribute

Mandatory

OPTIONAL = 'OPTIONAL' class-attribute instance-attribute

Optional

AIUC1ControlApplicationCategory

Bases: str, Enum

AIUC1 ControlApplication Category

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIUC1ControlApplicationCategory(str, Enum):
    """
    AIUC1 ControlApplication Category
    """
    CORE = "CORE"
    """
    Core Control
    """
    SUPPLEMENTAL = "SUPPLEMENTAL"
    """
    Supplemental Control
    """

CORE = 'CORE' class-attribute instance-attribute

Core Control

SUPPLEMENTAL = 'SUPPLEMENTAL' class-attribute instance-attribute

Supplemental Control

AIUC1EvidenceCategory

Bases: str, Enum

AIUC1 Evidence Category

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIUC1EvidenceCategory(str, Enum):
    """
    AIUC1 Evidence Category
    """
    TECHNICAL_IMPLEMENTATION = "TECHNICAL_IMPLEMENTATION"
    """
    Technical Implementation
    """
    LEGAL_POLICIES = "LEGAL_POLICIES"
    """
    Legal Policies
    """
    OPERATIONAL_PRACTICES = "OPERATIONAL_PRACTICES"
    """
    Operational Practices
    """
    THIRD_PARTY_EVALS = "THIRD_PARTY_EVALS"
    """
    Third-party Evals
    """

LEGAL_POLICIES = 'LEGAL_POLICIES' class-attribute instance-attribute

Legal Policies

OPERATIONAL_PRACTICES = 'OPERATIONAL_PRACTICES' class-attribute instance-attribute

Operational Practices

TECHNICAL_IMPLEMENTATION = 'TECHNICAL_IMPLEMENTATION' class-attribute instance-attribute

Technical Implementation

THIRD_PARTY_EVALS = 'THIRD_PARTY_EVALS' class-attribute instance-attribute

Third-party Evals

AIUC1Frequency

Bases: str, Enum

AIUC1 Frequency

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIUC1Frequency(str, Enum):
    """
    AIUC1 Frequency
    """
    MONTHS_3 = "MONTHS_3"
    """
    Every 3 months
    """
    MONTHS_6 = "MONTHS_6"
    """
    Every 6 months
    """
    MONTHS_12 = "MONTHS_12"
    """
    Every 12 months
    """

MONTHS_12 = 'MONTHS_12' class-attribute instance-attribute

Every 12 months

MONTHS_3 = 'MONTHS_3' class-attribute instance-attribute

Every 3 months

MONTHS_6 = 'MONTHS_6' class-attribute instance-attribute

Every 6 months

AIUC1RequirementType

Bases: str, Enum

AIUC1 Requirement Type

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIUC1RequirementType(str, Enum):
    """
    AIUC1 Requirement Type
    """
    DETECTIVE = "DETECTIVE"
    """
    Detective
    """
    PREVENTATIVE = "PREVENTATIVE"
    """
    Preventative
    """

DETECTIVE = 'DETECTIVE' class-attribute instance-attribute

Detective

PREVENTATIVE = 'PREVENTATIVE' class-attribute instance-attribute

Preventative

AIUser

Bases: Stakeholder

Individual or group that interacts with a system.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AIUser(Stakeholder):
    """
    Individual or group that interacts with a system.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AIUser',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a stakeholder is part of a stakeholder group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Action

Bases: RiskControl

Action to remediate a risk

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Action(RiskControl):
    """
    Action to remediate a risk
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_risk',
         'slot_usage': {'hasRelatedRisk': {'domain': 'Action',
                                           'name': 'hasRelatedRisk',
                                           'range': 'Risk'}}})

    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'Action',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasAiActorTask: Optional[list[str]] = Field(default=None, description="""Pertinent AI Actor Tasks for each subcategory. Not every AI Actor Task listed will apply to every suggested action in the subcategory (i.e., some apply to AI development and others apply to AI deployment).""", json_schema_extra = { "linkml_meta": {'domain_of': ['Action']} })
    detectsRiskConcept: Optional[list[str]] = Field(default=None, description="""The property airo:detectsRiskConcept indicates the control used for detecting risks, risk sources, consequences, and impacts.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskControl',
         'domain_of': ['Risk', 'RiskControl'],
         'exact_mappings': ['airo:detectsRiskConcept'],
         'inverse': 'isDetectedBy'} })
    mitigatesRiskConcept: Optional[list[str]] = Field(default=None, description="""Indicates the control used for mitigating risks, risk sources, consequences, and impacts.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskControl',
         'domain_of': ['RiskControl'],
         'exact_mappings': ['airo:mitigatesRiskConcept'],
         'inverse': 'isMitigatedBy'} })
    isDetectedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is detected by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'detectsRiskConcept'} })
    isMitigatedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is mitigated by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'mitigatesRiskConcept'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    isApplicableinLocality: Optional[list[str]] = Field(default=None, description="""A relationship where an entity has is applicable in these localities.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Control', 'Policy'], 'slot_uri': 'nexus:isApplicableinLocality'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    type: Literal["Action"] = Field(default="Action", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

Adapter

Bases: LargeLanguageModel, Entry

Adapter-based methods add extra trainable parameters after the attention and fully-connected layers of a frozen pretrained model to reduce memory-usage and speed up training. The adapters are typically small but demonstrate comparable performance to a fully finetuned model and enable training larger models with fewer resources. (https://huggingface.co/docs/peft/en/conceptual_guides/adapter)

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Adapter(LargeLanguageModel, Entry):
    """
    Adapter-based methods add extra trainable parameters after the attention and fully-connected layers of a frozen pretrained model to reduce memory-usage and speed up training. The adapters are typically small but demonstrate comparable performance to a fully finetuned model and enable training larger models with fewer resources. (https://huggingface.co/docs/peft/en/conceptual_guides/adapter)
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_intrinsic',
         'mixins': ['LargeLanguageModel'],
         'slot_usage': {'hasRelatedRisk': {'domain': 'Adapter',
                                           'name': 'hasRelatedRisk',
                                           'range': 'Risk'},
                        'implementsCapability': {'description': 'Indicates that this '
                                                                'adapter implements a '
                                                                'specific capability',
                                                 'domain': 'Adapter',
                                                 'inverse': 'implementedByAdapter',
                                                 'name': 'implementsCapability',
                                                 'range': 'Capability'}}})

    hasAdapterType: Optional[list[AdapterType]] = Field(default=None, description="""The Adapter type, for example: LORA, ALORA, X-LORA""", json_schema_extra = { "linkml_meta": {'domain_of': ['Adapter']} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'Adapter',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    adaptsModel: Optional[list[str]] = Field(default=None, description="""The LargeLanguageModel being adapted""", json_schema_extra = { "linkml_meta": {'domain_of': ['Adapter']} })
    implementsCapability: Optional[list[str]] = Field(default=None, description="""Indicates that this adapter implements a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Adapter',
         'domain_of': ['Adapter', 'LLMIntrinsic'],
         'inverse': 'implementedByAdapter'} })
    hasCapability: Optional[list[str]] = Field(default=None, description="""Indicates the technical capabilities this entry possesses.
""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'tech:hasCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    numParameters: Optional[int] = Field(default=None, description="""A property indicating the number of parameters in a LLM.""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    numTrainingTokens: Optional[int] = Field(default=None, description="""The number of tokens a AI model was trained on.""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    contextWindowSize: Optional[int] = Field(default=None, description="""The total length, in bytes, of an AI model's context window.""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    hasInputModality: Optional[list[str]] = Field(default=None, description="""A relationship indicating the input modalities supported by an AI component. Examples include text, image, video.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    hasOutputModality: Optional[list[str]] = Field(default=None, description="""A relationship indicating the output modalities supported by an AI component. Examples include text, image, video.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    hasTrainingData: Optional[list[str]] = Field(default=None, description="""A relationship indicating the datasets an AI model was trained on.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel'], 'slot_uri': 'airo:hasTrainingData'} })
    fine_tuning: Optional[str] = Field(default=None, description="""A description of the fine-tuning mechanism(s) applied to a model.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    supported_languages: Optional[list[str]] = Field(default=None, description="""A list of languages, expressed as ISO two letter codes. For example, 'jp, fr, en, de'""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    isPartOf: Optional[str] = Field(default=None, description="""Annotation that a Large Language model is part of a family of models""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Adapter"] = Field(default="Adapter", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasEvaluation: Optional[list[str]] = Field(default=None, description="""A relationship indicating that an entity has an AI evaluation result.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel', 'ThirdPartyEvaluationEngagement'],
         'slot_uri': 'dqv:hasQualityMeasurement'} })
    architecture: Optional[str] = Field(default=None, description="""A description of the architecture of an AI such as 'Decoder-only'.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    gpu_hours: Optional[int] = Field(default=None, description="""GPU consumption in terms of hours""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    power_consumption_w: Optional[int] = Field(default=None, description="""power consumption in Watts""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    carbon_emitted: Optional[float] = Field(default=None, description="""The number of tons of carbon dioxide equivalent that are emitted during training""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel'],
         'unit': {'descriptive_name': 'tons of CO2 equivalent', 'symbol': 't CO2-eq'}} })
    hasRiskControl: Optional[list[str]] = Field(default=None, description="""Indicates the control measures associated with a system or component to modify risks.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel'], 'slot_uri': 'airo:hasRiskControl'} })
    isProducedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance which produces this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasModelCard: Optional[list[str]] = Field(default=None, description="""A relationship to model card references.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    performsTask: Optional[list[str]] = Field(default=None, description="""relationship indicating the AI tasks an AI model can perform.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    isProvidedBy: Optional[str] = Field(default=None, description="""Indicates provider of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'airo:isProvidedBy'} })

AdapterType

Bases: str, Enum

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AdapterType(str, Enum):
    LORA = "LORA"
    """
    Low-rank adapters, or LoRAs, are a fast way to give generalist large language models targeted knowledge and skills so they can do things like summarize IT manuals or rate the accuracy of their own answers. LoRA reduces the number of trainable parameters by learning pairs of rank-decompostion matrices while freezing the original weights. This vastly reduces the storage requirement for large language models adapted to specific tasks and enables efficient task-switching during deployment all without introducing inference latency. LoRA also outperforms several other adaptation methods including adapter, prefix-tuning, and fine-tuning. See arXiv:2106.09685
    """
    ALORA = "ALORA"
    """
    Activated LoRA (aLoRA) is a low rank adapter architecture that allows for reusing existing base model KV cache for more efficient inference, unlike standard LoRA models. As a result, aLoRA models can be quickly invoked as-needed for specialized tasks during (long) flows where the base model is primarily used, avoiding potentially expensive prefill costs in terms of latency, throughput, and GPU memory. See arXiv:2504.12397 for further details.
    """
    X_LORA = "X-LORA"
    """
    Mixture of LoRA Experts (X-LoRA) is a mixture of experts method for LoRA which works by using dense or sparse gating to dynamically activate LoRA experts.
    """

ALORA = 'ALORA' class-attribute instance-attribute

Activated LoRA (aLoRA) is a low rank adapter architecture that allows for reusing existing base model KV cache for more efficient inference, unlike standard LoRA models. As a result, aLoRA models can be quickly invoked as-needed for specialized tasks during (long) flows where the base model is primarily used, avoiding potentially expensive prefill costs in terms of latency, throughput, and GPU memory. See arXiv:2504.12397 for further details.

LORA = 'LORA' class-attribute instance-attribute

Low-rank adapters, or LoRAs, are a fast way to give generalist large language models targeted knowledge and skills so they can do things like summarize IT manuals or rate the accuracy of their own answers. LoRA reduces the number of trainable parameters by learning pairs of rank-decompostion matrices while freezing the original weights. This vastly reduces the storage requirement for large language models adapted to specific tasks and enables efficient task-switching during deployment all without introducing inference latency. LoRA also outperforms several other adaptation methods including adapter, prefix-tuning, and fine-tuning. See arXiv:2106.09685

X_LORA = 'X-LORA' class-attribute instance-attribute

Mixture of LoRA Experts (X-LoRA) is a mixture of experts method for LoRA which works by using dense or sparse gating to dynamically activate LoRA experts.

AiAgent

Bases: AiSystem

An artificial intelligence (AI) agent refers to a system or program that is capable of autonomously performing tasks on behalf of a user or another system by designing its workflow and utilizing available tools.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiAgent(AiSystem):
    """
    An artificial intelligence (AI) agent refers to a system or program that is capable of autonomously performing tasks on behalf of a user or another system by designing its workflow and utilizing available tools.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'mixin': True,
         'slot_usage': {'isProvidedBy': {'description': 'A relationship indicating the '
                                                        'AI agent has been provided by '
                                                        'an AI systems provider.',
                                         'name': 'isProvidedBy'}}})

    isComposedOf: Optional[list[str]] = Field(default=None, description="""Relationship indicating the AI components from which a complete AI system is composed.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'AiEval']} })
    hasEuAiSystemType: Optional[AiSystemType] = Field(default=None, description="""The type of system as defined by the EU AI Act.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem']} })
    hasEuRiskCategory: Optional[EuAiRiskCategory] = Field(default=None, description="""The risk category of an AI system as defined by the EU AI Act.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem']} })
    hasCapability: Optional[list[str]] = Field(default=None, description="""Indicates the technical capabilities this entry possesses.
""", json_schema_extra = { "linkml_meta": {'domain': 'AiSystem',
         'domain_of': ['AiSystem', 'Adapter', 'LLMIntrinsic'],
         'inverse': 'possessedByAi',
         'slot_uri': 'tech:hasCapability'} })
    isAppliedWithinDomain: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:isAppliedWithinDomain'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    hasPurpose: Optional[list[str]] = Field(default=None, description="""Indicates the purpose of an entity, e.g. AI system, components.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasPurpose'} })
    hasStakeholder: Optional[list[str]] = Field(default=None, description="""Indicates stakeholders of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasStakeholder'} })
    isDeployedBy: Optional[str] = Field(default=None, description="""Indicates the deployer of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:isDeployedBy'} })
    isDevelopedBy: Optional[str] = Field(default=None, description="""Indicates the developer of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:isDevelopedBy'} })
    hasAISubject: Optional[list[str]] = Field(default=None, description="""Indicates the subjects of an AI system""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasAISubject'} })
    hasAIUser: Optional[list[str]] = Field(default=None, description="""Indicate the end-user of an AI system.""", json_schema_extra = { "linkml_meta": {'domain': 'AiSystem', 'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasAiUser'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'AiSystem',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    isProducedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance which produces this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasModelCard: Optional[list[str]] = Field(default=None, description="""A relationship to model card references.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    performsTask: Optional[list[str]] = Field(default=None, description="""relationship indicating the AI tasks an AI model can perform.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    isProvidedBy: Optional[str] = Field(default=None, description="""A relationship indicating the AI agent has been provided by an AI systems provider.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'airo:isProvidedBy'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["AiAgent"] = Field(default="AiAgent", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiEval

Bases: Entity

An AI Evaluation, e.g. a metric, benchmark, unitxt card evaluation, a question or a combination of such entities.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiEval(Entity):
    """
    An AI Evaluation, e.g. a metric, benchmark, unitxt card evaluation, a question or a combination of such entities.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'dqv:Metric',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'slot_usage': {'hasRelatedRisk': {'domain': 'AiEval',
                                           'name': 'hasRelatedRisk',
                                           'range': 'Risk'},
                        'isComposedOf': {'description': 'A relationship indicating '
                                                        'that an AI evaluation maybe '
                                                        'composed of other AI '
                                                        "evaluations (e.g. it's an "
                                                        'overall average of other '
                                                        'scores).',
                                         'name': 'isComposedOf',
                                         'range': 'AiEval'}}})

    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasDataset: Optional[list[str]] = Field(default=None, description="""A relationship to datasets that are used.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval']} })
    hasTasks: Optional[list[str]] = Field(default=None, description="""The tasks or evaluations the benchmark is intended to assess.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval', 'EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasImplementation: Optional[list[str]] = Field(default=None, description="""A relationship to a implementation defining the risk evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval'], 'slot_uri': 'schema:url'} })
    hasUnitxtCard: Optional[list[str]] = Field(default=None, description="""A relationship to a Unitxt card defining the risk evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval'], 'slot_uri': 'schema:url'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'AiEval',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    bestValue: Optional[str] = Field(default=None, description="""Annotation of the best possible result of the evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval']} })
    hasBenchmarkMetadata: Optional[list[str]] = Field(default=None, description="""A relationship to a Benchmark Metadata Card which contains metadata about the benchmark.""", json_schema_extra = { "linkml_meta": {'domain': 'AiEval', 'domain_of': ['AiEval'], 'inverse': 'describesAiEval'} })
    isComposedOf: Optional[list[str]] = Field(default=None, description="""A relationship indicating that an AI evaluation maybe composed of other AI evaluations (e.g. it's an overall average of other scores).""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'AiEval']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiEvalResult

Bases: Fact, Entity

The result of an evaluation for a specific AI model.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiEvalResult(Fact, Entity):
    """
    The result of an evaluation for a specific AI model.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'dqv:QualityMeasurement',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'mixins': ['Fact']})

    isResultOf: Optional[str] = Field(default=None, description="""A relationship indicating that an entity is the result of an AI evaluation.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEvalResult'], 'slot_uri': 'dqv:isMeasurementOf'} })
    value: str = Field(default=..., description="""Some numeric or string value""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact']} })
    evidence: Optional[str] = Field(default=None, description="""Evidence provides a source (typical a chunk, paragraph or link) describing where some value was found or how it was generated.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact', 'ConditionAssessment']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiLifecyclePhase

Bases: Entity

A Phase of AI lifecycle which indicates evolution of the system from conception through retirement.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiLifecyclePhase(Entity):
    """
    A Phase of AI lifecycle which indicates evolution of the system from conception through retirement.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'airo:AILifecyclePhase',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiModel

Bases: AIComponent, BaseAi

A base AI Model class. No assumption about the type (SVM, LLM, etc.). Subclassed by model types (see LargeLanguageModel).

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiModel(AIComponent, BaseAi):
    """
    A base AI Model class. No assumption about the type (SVM, LLM, etc.). Subclassed by model types (see LargeLanguageModel).
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'mixin': True,
         'mixins': ['AIComponent']})

    hasEvaluation: Optional[list[str]] = Field(default=None, description="""A relationship indicating that an entity has an AI evaluation result.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel', 'ThirdPartyEvaluationEngagement'],
         'slot_uri': 'dqv:hasQualityMeasurement'} })
    architecture: Optional[str] = Field(default=None, description="""A description of the architecture of an AI such as 'Decoder-only'.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    gpu_hours: Optional[int] = Field(default=None, description="""GPU consumption in terms of hours""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    power_consumption_w: Optional[int] = Field(default=None, description="""power consumption in Watts""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    carbon_emitted: Optional[float] = Field(default=None, description="""The number of tons of carbon dioxide equivalent that are emitted during training""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel'],
         'unit': {'descriptive_name': 'tons of CO2 equivalent', 'symbol': 't CO2-eq'}} })
    hasRiskControl: Optional[list[str]] = Field(default=None, description="""Indicates the control measures associated with a system or component to modify risks.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel'], 'slot_uri': 'airo:hasRiskControl'} })
    isProducedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance which produces this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasModelCard: Optional[list[str]] = Field(default=None, description="""A relationship to model card references.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    performsTask: Optional[list[str]] = Field(default=None, description="""relationship indicating the AI tasks an AI model can perform.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    isProvidedBy: Optional[str] = Field(default=None, description="""Indicates provider of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'airo:isProvidedBy'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiModelValidation

Bases: AiLifecyclePhase

AI model validation steps that have been performed after the model training to ensure high AI model quality.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiModelValidation(AiLifecyclePhase):
    """
    AI model validation steps that have been performed after the model training to ensure high AI model quality.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiOffice

Bases: Organization

The EU AI Office (https://digital-strategy.ec.europa.eu/en/policies/ai-office)

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiOffice(Organization):
    """
    The EU AI Office (https://digital-strategy.ec.europa.eu/en/policies/ai-office)
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'schema:Organization',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/eu_ai_act'})

    grants_license: Optional[str] = Field(default=None, description="""A relationship from a granting entity such as an Organization to a License instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Organization']} })
    type: Literal["AiOffice"] = Field(default="AiOffice", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiProvider

Bases: Organization

A provider under the AI Act is defined by Article 3(3) as a natural or legal person or body that develops an AI system or general-purpose AI model or has an AI system or general-purpose AI model developed; and places that ystem or model on the market, or puts that system into service, under the provider's own name or trademark, whether for payment or free for charge.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiProvider(Organization):
    """
    A provider under the AI Act is defined by Article 3(3) as a natural or legal person or body that develops an AI system or general-purpose AI model or has an AI system or general-purpose AI model developed; and places that ystem or model on the market, or puts that system into service, under the provider's own name or trademark, whether for payment or free for charge.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AIProvider',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    grants_license: Optional[str] = Field(default=None, description="""A relationship from a granting entity such as an Organization to a License instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Organization']} })
    type: Literal["AiProvider"] = Field(default="AiProvider", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiSystem

Bases: BaseAi, Entry

A compound AI System composed of one or more AI capablities. ChatGPT is an example of an AI system which deploys multiple GPT AI models.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiSystem(BaseAi, Entry):
    """
    A compound AI System composed of one or more AI capablities. ChatGPT is an example of an AI system which deploys multiple GPT AI models.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AISystem',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'mixin': True,
         'mixins': ['BaseAi'],
         'slot_usage': {'hasCapability': {'domain': 'AiSystem',
                                          'inverse': 'possessedByAi',
                                          'name': 'hasCapability'},
                        'hasRelatedRisk': {'domain': 'AiSystem',
                                           'name': 'hasRelatedRisk',
                                           'range': 'Risk'},
                        'isComposedOf': {'description': 'Relationship indicating the '
                                                        'AI components from which a '
                                                        'complete AI system is '
                                                        'composed.',
                                         'name': 'isComposedOf',
                                         'range': 'BaseAi'}}})

    isComposedOf: Optional[list[str]] = Field(default=None, description="""Relationship indicating the AI components from which a complete AI system is composed.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'AiEval']} })
    hasEuAiSystemType: Optional[AiSystemType] = Field(default=None, description="""The type of system as defined by the EU AI Act.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem']} })
    hasEuRiskCategory: Optional[EuAiRiskCategory] = Field(default=None, description="""The risk category of an AI system as defined by the EU AI Act.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem']} })
    hasCapability: Optional[list[str]] = Field(default=None, description="""Indicates the technical capabilities this entry possesses.
""", json_schema_extra = { "linkml_meta": {'domain': 'AiSystem',
         'domain_of': ['AiSystem', 'Adapter', 'LLMIntrinsic'],
         'inverse': 'possessedByAi',
         'slot_uri': 'tech:hasCapability'} })
    isAppliedWithinDomain: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:isAppliedWithinDomain'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    hasPurpose: Optional[list[str]] = Field(default=None, description="""Indicates the purpose of an entity, e.g. AI system, components.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasPurpose'} })
    hasStakeholder: Optional[list[str]] = Field(default=None, description="""Indicates stakeholders of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasStakeholder'} })
    isDeployedBy: Optional[str] = Field(default=None, description="""Indicates the deployer of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:isDeployedBy'} })
    isDevelopedBy: Optional[str] = Field(default=None, description="""Indicates the developer of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:isDevelopedBy'} })
    hasAISubject: Optional[list[str]] = Field(default=None, description="""Indicates the subjects of an AI system""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasAISubject'} })
    hasAIUser: Optional[list[str]] = Field(default=None, description="""Indicate the end-user of an AI system.""", json_schema_extra = { "linkml_meta": {'domain': 'AiSystem', 'domain_of': ['AiSystem'], 'slot_uri': 'airo:hasAiUser'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'AiSystem',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    isProducedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance which produces this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasModelCard: Optional[list[str]] = Field(default=None, description="""A relationship to model card references.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    performsTask: Optional[list[str]] = Field(default=None, description="""relationship indicating the AI tasks an AI model can perform.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    isProvidedBy: Optional[str] = Field(default=None, description="""Indicates provider of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'airo:isProvidedBy'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["AiSystem"] = Field(default="AiSystem", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiSystemType

Bases: str, Enum

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiSystemType(str, Enum):
    GPAI = "GPAI"
    """
    General-purpose AI (GPAI)
    """
    GPAI_OS = "GPAI_OS"
    """
    General-purpose AI (GPAI) models released under free and open-source licences
    """
    PROHIBITED = "PROHIBITED"
    """
    Prohibited AI system due to unacceptable risk category (e.g. social scoring systems and manipulative AI).
    """
    SCIENTIFIC_RD = "SCIENTIFIC_RD"
    """
    AI used for scientific research and development
    """
    MILITARY_SECURITY = "MILITARY_SECURITY"
    """
    AI used for military, defense and security purposes.
    """
    HIGH_RISK = "HIGH_RISK"
    """
    AI systems pursuant to Article 6(1)(2) Classification Rules for High-Risk AI Systems
    """

GPAI = 'GPAI' class-attribute instance-attribute

General-purpose AI (GPAI)

GPAI_OS = 'GPAI_OS' class-attribute instance-attribute

General-purpose AI (GPAI) models released under free and open-source licences

HIGH_RISK = 'HIGH_RISK' class-attribute instance-attribute

AI systems pursuant to Article 6(1)(2) Classification Rules for High-Risk AI Systems

MILITARY_SECURITY = 'MILITARY_SECURITY' class-attribute instance-attribute

AI used for military, defense and security purposes.

PROHIBITED = 'PROHIBITED' class-attribute instance-attribute

Prohibited AI system due to unacceptable risk category (e.g. social scoring systems and manipulative AI).

SCIENTIFIC_RD = 'SCIENTIFIC_RD' class-attribute instance-attribute

AI used for scientific research and development

AiTask

Bases: Entry

A task, such as summarization and classification, performed by an AI.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiTask(Entry):
    """
    A task, such as summarization and classification, performed by an AI.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:AiCapability',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'slot_usage': {'requiresCapability': {'domain': 'AiTask',
                                               'name': 'requiresCapability',
                                               'range': 'Capability'}}})

    requiresCapability: Optional[list[str]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'AiTask',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["AiTask"] = Field(default="AiTask", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiTaskDomain

Bases: Group

A grouping of AI Tasks by domain.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiTaskDomain(Group):
    """
    A grouping of AI Tasks by domain.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:AiTaskDomain',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'slot_usage': {'hasPart': {'description': 'A relationship where an AI Task '
                                                   'domain has a group.',
                                    'name': 'hasPart',
                                    'range': 'AiTaskGroup'}}})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasPart: Optional[list[str]] = Field(default=None, description="""A relationship where an AI Task domain has a group.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group',
                       'RiskControlGroup',
                       'RiskGroup',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup'],
         'slot_uri': 'skos:member'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    belongsToDomain: Optional[Any] = Field(default=None, description="""A relationship where a group belongs to a domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group', 'CapabilityGroup'], 'slot_uri': 'schema:isPartOf'} })
    type: Literal["AiTaskDomain"] = Field(default="AiTaskDomain", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement'],
         'ifabsent': 'string(Group)'} })
    narrower: Optional[list[str]] = Field(default=None, description="""Related concepts that are narrower in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    broader: Optional[list[str]] = Field(default=None, description="""Related concepts that are broader in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiTaskGroup

Bases: Group

A group of AI Tasks.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiTaskGroup(Group):
    """
    A group of AI Tasks.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:AiTaskGroup',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'slot_usage': {'hasPart': {'description': 'A relationship where an AI task '
                                                   'group has an AI task.',
                                    'name': 'hasPart',
                                    'range': 'AiTask'},
                        'isPartOf': {'name': 'isPartOf', 'range': 'AiTaskDomain'}}})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasPart: Optional[list[str]] = Field(default=None, description="""A relationship where an AI task group has an AI task.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group',
                       'RiskControlGroup',
                       'RiskGroup',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup'],
         'slot_uri': 'skos:member'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    belongsToDomain: Optional[Any] = Field(default=None, description="""A relationship where a group belongs to a domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group', 'CapabilityGroup'], 'slot_uri': 'schema:isPartOf'} })
    type: Literal["AiTaskGroup"] = Field(default="AiTaskGroup", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement'],
         'ifabsent': 'string(Group)'} })
    narrower: Optional[list[str]] = Field(default=None, description="""Related concepts that are narrower in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    broader: Optional[list[str]] = Field(default=None, description="""Related concepts that are broader in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

AiTaskTaxonomy

Bases: Taxonomy

A taxonomy of AI Tasks

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class AiTaskTaxonomy(Taxonomy):
    """
    A taxonomy of AI Tasks
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    version: Optional[str] = Field(default=None, description="""The version of the entity embodied by a specified resource.""", json_schema_extra = { "linkml_meta": {'domain_of': ['License',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'AiTaskTaxonomy'],
         'slot_uri': 'schema:version'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    type: Literal["AiTaskTaxonomy"] = Field(default="AiTaskTaxonomy", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

BaseAi

Bases: Entity

Any type of AI, be it a LLM, RL agent, SVM, etc.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class BaseAi(Entity):
    """
    Any type of AI, be it a LLM, RL agent, SVM, etc.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'slot_usage': {'isProvidedBy': {'description': 'Indicates provider of an AI '
                                                        'system or component.',
                                         'name': 'isProvidedBy',
                                         'range': 'AiProvider',
                                         'slot_uri': 'airo:isProvidedBy'}}})

    isProducedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance which produces this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasModelCard: Optional[list[str]] = Field(default=None, description="""A relationship to model card references.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    performsTask: Optional[list[str]] = Field(default=None, description="""relationship indicating the AI tasks an AI model can perform.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    isProvidedBy: Optional[str] = Field(default=None, description="""Indicates provider of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'airo:isProvidedBy'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

BenchmarkMetadataCard

Bases: Entity

Benchmark metadata cards offer a standardized way to document LLM benchmarks clearly and transparently. Inspired by Model Cards and Datasheets, Benchmark metadata cards help researchers and practitioners understand exactly what benchmarks test, how they relate to real-world risks, and how to interpret their results responsibly. This is an implementation of the design set out in BenchmarkCards: Large Language Model and Risk Reporting (https://doi.org/10.48550/arXiv.2410.12974)

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class BenchmarkMetadataCard(Entity):
    """
    Benchmark metadata cards offer a standardized way to document LLM benchmarks clearly and transparently. Inspired by Model Cards and Datasheets, Benchmark metadata cards help researchers and practitioners understand exactly what benchmarks test, how they relate to real-world risks, and how to interpret their results responsibly. This is an implementation of the design set out in BenchmarkCards: Large Language Model and Risk Reporting (https://doi.org/10.48550/arXiv.2410.12974)
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:benchmarkmetadatacard',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'slot_usage': {'hasRelatedRisk': {'domain': 'BenchmarkMetadataCard',
                                           'name': 'hasRelatedRisk',
                                           'range': 'RiskConcept'}}})

    describesAiEval: Optional[list[str]] = Field(default=None, description="""A relationship where a BenchmarkMetadataCard describes an AI evaluation (benchmark).""", json_schema_extra = { "linkml_meta": {'domain': 'BenchmarkMetadataCard',
         'domain_of': ['BenchmarkMetadataCard'],
         'inverse': 'hasBenchmarkMetadata'} })
    hasDataType: Optional[list[str]] = Field(default=None, description="""The type of data used in the benchmark (e.g., text, images, or multi-modal)""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDomains: Optional[list[str]] = Field(default=None, description="""The specific domains or areas where the benchmark is applied (e.g., natural language processing, computer vision).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasLanguages: Optional[list[str]] = Field(default=None, description="""The languages included in the dataset used by the benchmark (e.g., English, multilingual).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasSimilarBenchmarks: Optional[list[str]] = Field(default=None, description="""Benchmarks that are closely related in terms of goals or data type.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasResources: Optional[list[str]] = Field(default=None, description="""Links to relevant resources, such as repositories or papers related to the benchmark.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasGoal: Optional[str] = Field(default=None, description="""The specific goal or primary use case the benchmark is designed for.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasAudience: Optional[list[str]] = Field(default=None, description="""The intended audience, such as researchers, developers, policymakers, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasTasks: Optional[list[str]] = Field(default=None, description="""The tasks or evaluations the benchmark is intended to assess.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval', 'EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasLimitations: Optional[list[str]] = Field(default=None, description="""Limitations in evaluating or addressing risks, such as gaps in demographic coverage or specific domains.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasOutOfScopeUses: Optional[list[str]] = Field(default=None, description="""Use cases where the benchmark is not designed to be applied and could give misleading results.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasDataSource: Optional[list[str]] = Field(default=None, description="""The origin or source of the data used in the benchmark (e.g., curated datasets, user submissions).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDataSize: Optional[str] = Field(default=None, description="""The size of the dataset, including the number of data points or examples.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDataFormat: Optional[list[str]] = Field(default=None, description="""The structure and modality of the data (e.g., sentence pairs, question-answer format, tabular data).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasAnnotation: Optional[list[str]] = Field(default=None, description="""The process used to annotate or label the dataset, including who or what performed the annotations (e.g., human annotators, automated processes).""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasMethods: Optional[list[str]] = Field(default=None, description="""The evaluation techniques applied within the benchmark.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasMetrics: Optional[list[str]] = Field(default=None, description="""The specific performance metrics used to assess models (e.g., accuracy, F1 score, precision, recall).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasCalculation: Optional[list[str]] = Field(default=None, description="""The way metrics are computed based on model outputs and the benchmark data.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasInterpretation: Optional[list[str]] = Field(default=None, description="""How users should interpret the scores or results from the metrics.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasBaselineResults: Optional[list[str]] = Field(default=None, description="""The results of well-known or widely used models to give context to new performance scores.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasValidation: Optional[list[str]] = Field(default=None, description="""Measures taken to ensure that the benchmark provides valid and reliable evaluations.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'BenchmarkMetadataCard',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    hasDemographicAnalysis: Optional[list[str]] = Field(default=None, description="""How the benchmark evaluates performance across different demographic groups (e.g., gender, race).""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasConsiderationPrivacyAndAnonymity: Optional[list[str]] = Field(default=None, description="""How any personal or sensitive data is handled and whether any anonymization techniques are applied.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasConsiderationConsentProcedures: Optional[list[str]] = Field(default=None, description="""Information on how consent was obtained (if applicable), especially for datasets involving personal data.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasConsiderationComplianceWithRegulations: Optional[list[str]] = Field(default=None, description="""Compliance with relevant legal or ethical regulations (if applicable).""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    name: Optional[str] = Field(default=None, description="""The official name of the benchmark.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard']} })
    overview: Optional[str] = Field(default=None, description="""A brief description of the benchmark's main goals and scope.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BenchmarkMetadataCard']} })
    type: Literal["BenchmarkMetadataCard"] = Field(default="BenchmarkMetadataCard", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Capability

Bases: CapabilityConcept, Entry

A specific AI capability or ability, such as reading comprehension, logical reasoning, or code generation. Aligned with the W3C DPV AI extension dpv-ai:Capability, representing what an AI technology is capable of achieving or providing. Capabilities are distinct from: (1) the intended purpose for which the technology is designed, (2) the actual tasks performed in a specific deployment context, and (3) the technical implementation mechanisms (intrinsics, adapters) that enable the capability.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Capability(CapabilityConcept, Entry):
    """
    A specific AI capability or ability, such as reading comprehension, logical reasoning, or code generation. Aligned with the W3C DPV AI extension dpv-ai:Capability, representing what an AI technology is capable of achieving or providing.
    Capabilities are distinct from: (1) the intended purpose for which the technology is designed, (2) the actual tasks performed in a specific deployment context, and (3) the technical implementation mechanisms (intrinsics, adapters) that enable the capability.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'broad_mappings': ['tech:Capability'],
         'class_uri': 'ai:Capability',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_capability',
         'mixins': ['CapabilityConcept'],
         'slot_usage': {'implementedByAdapter': {'description': 'Indicates that this '
                                                                'capability is '
                                                                'implemented by a '
                                                                'specific adapter. '
                                                                'This relationship '
                                                                'distinguishes the '
                                                                'abstract capability '
                                                                '(what can be done) '
                                                                'from the technical '
                                                                'implementation '
                                                                'mechanism (how it is '
                                                                'added/extended via '
                                                                'adapters).',
                                                 'domain': 'Capability',
                                                 'name': 'implementedByAdapter',
                                                 'range': 'Adapter'},
                        'isPartOf': {'description': 'A relationship where a capability '
                                                    'is part of a capability group',
                                     'name': 'isPartOf',
                                     'range': 'CapabilityGroup'},
                        'requiredByTask': {'description': 'Indicates that this '
                                                          'capability is required to '
                                                          'perform a specific AI task. '
                                                          'This links abstract '
                                                          'capabilities (technical '
                                                          'abilities) to concrete '
                                                          'tasks (application-level '
                                                          'operations). An AI system '
                                                          'with this capability can '
                                                          'perform tasks that require '
                                                          'it.',
                                           'domain': 'Capability',
                                           'name': 'requiredByTask',
                                           'range': 'AiTask'}}})

    requiredByTask: Optional[list[str]] = Field(default=None, description="""Indicates that this capability is required to perform a specific AI task. This links abstract capabilities (technical abilities) to concrete tasks (application-level operations). An AI system with this capability can perform tasks that require it.""", json_schema_extra = { "linkml_meta": {'domain': 'Capability',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    implementedByAdapter: Optional[list[str]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Capability',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a capability is part of a capability group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Capability"] = Field(default="Capability", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

CapabilityConcept

Bases: Concept

An umbrella term for referring to capability domains, groups, and individual capabilities.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class CapabilityConcept(Concept):
    """
    An umbrella term for referring to capability domains, groups, and individual capabilities.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:CapabilityConcept',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_capability',
         'mixin': True})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })
    type: Literal["CapabilityConcept"] = Field(default="CapabilityConcept", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

CapabilityDomain

Bases: CapabilityConcept, Group

A high-level domain of AI capabilities (e.g., Language, Reasoning, Knowledge)

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class CapabilityDomain(CapabilityConcept, Group):
    """
    A high-level domain of AI capabilities (e.g., Language, Reasoning, Knowledge)
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:CapabilityDomain',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_capability',
         'mixins': ['CapabilityConcept'],
         'slot_usage': {'hasPart': {'description': 'A relationship where a capability '
                                                   'domain has capability groups',
                                    'name': 'hasPart',
                                    'range': 'CapabilityGroup'}}})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasPart: Optional[list[str]] = Field(default=None, description="""A relationship where a capability domain has capability groups""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group',
                       'RiskControlGroup',
                       'RiskGroup',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup'],
         'slot_uri': 'skos:member'} })
    belongsToDomain: Optional[Any] = Field(default=None, description="""A relationship where a group belongs to a domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group', 'CapabilityGroup'], 'slot_uri': 'schema:isPartOf'} })
    type: Literal["CapabilityDomain"] = Field(default="CapabilityDomain", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement'],
         'ifabsent': 'string(Group)'} })
    narrower: Optional[list[str]] = Field(default=None, description="""Related concepts that are narrower in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    broader: Optional[list[str]] = Field(default=None, description="""Related concepts that are broader in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

CapabilityGroup

Bases: CapabilityConcept, Group

A group of AI capabilities that are part of a capability taxonomy, organized under a domain

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class CapabilityGroup(CapabilityConcept, Group):
    """
    A group of AI capabilities that are part of a capability taxonomy, organized under a domain
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_capability',
         'mixins': ['CapabilityConcept'],
         'slot_usage': {'belongsToDomain': {'description': 'A relationship where a '
                                                           'capability group belongs '
                                                           'to a capability domain',
                                            'name': 'belongsToDomain',
                                            'range': 'CapabilityDomain'},
                        'hasPart': {'description': 'A relationship where a capability '
                                                   'group has capabilities',
                                    'name': 'hasPart',
                                    'range': 'Capability'},
                        'isPartOf': {'description': 'A relationship where a capability '
                                                    'group belongs to a capability '
                                                    'domain',
                                     'name': 'isPartOf',
                                     'range': 'CapabilityDomain'}}})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a capability group belongs to a capability domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    hasPart: Optional[list[str]] = Field(default=None, description="""A relationship where a capability group has capabilities""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group',
                       'RiskControlGroup',
                       'RiskGroup',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup'],
         'slot_uri': 'skos:member'} })
    belongsToDomain: Optional[str] = Field(default=None, description="""A relationship where a capability group belongs to a capability domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group', 'CapabilityGroup'], 'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    type: Literal["CapabilityGroup"] = Field(default="CapabilityGroup", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement'],
         'ifabsent': 'string(Group)'} })
    narrower: Optional[list[str]] = Field(default=None, description="""Related concepts that are narrower in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    broader: Optional[list[str]] = Field(default=None, description="""Related concepts that are broader in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

CapabilityTaxonomy

Bases: Taxonomy

A taxonomy of AI capabilities describing the abilities of AI systems.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class CapabilityTaxonomy(Taxonomy):
    """
    A taxonomy of AI capabilities describing the abilities of AI systems.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'skos:ConceptScheme',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_capability'})

    version: Optional[str] = Field(default=None, description="""The version of the entity embodied by a specified resource.""", json_schema_extra = { "linkml_meta": {'domain_of': ['License',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'AiTaskTaxonomy'],
         'slot_uri': 'schema:version'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    type: Literal["CapabilityTaxonomy"] = Field(default="CapabilityTaxonomy", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Certification

Bases: Entry

Certification mechanisms, seals, and marks for the purpose of demonstrating compliance

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Certification(Entry):
    """
    Certification mechanisms, seals, and marks for the purpose of demonstrating compliance
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'dpv:Certification',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    type: Literal["Certification"] = Field(default="Certification", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Concept

Bases: Entity

A concept

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Concept(Entity):
    """
    A concept
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'skos:Concept',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common',
         'mixin': True})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })
    type: Literal["Concept"] = Field(default="Concept", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ConditionAssessment

Bases: ConfiguredBaseModel

One answer of a completed checklist, for one condition of the evaluation standard.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ConditionAssessment(ConfiguredBaseModel):
    """
    One answer of a completed checklist, for one condition of the evaluation standard.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:ConditionAssessment',
         'close_mappings': ['earl:Assertion'],
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'related_mappings': ['earl:TestResult'],
         'rules': [{'description': 'A justification is required when a condition is '
                                   'not fulfilled literally.',
                    'postconditions': {'slot_conditions': {'justification': {'name': 'justification',
                                                                             'required': True}}},
                    'preconditions': {'slot_conditions': {'hasConformanceOutcome': {'any_of': [{'equals_string': 'NOT_FULFILLED'},
                                                                                               {'equals_string': 'ALTERNATIVE_MEANS'}],
                                                                                    'name': 'hasConformanceOutcome'}}}}],
         'slot_usage': {'assessesCondition': {'name': 'assessesCondition',
                                              'required': True},
                        'evidence': {'description': 'Notes or evidence supporting the '
                                                    'answer, e.g. a link to a '
                                                    'published policy.',
                                     'name': 'evidence'},
                        'hasConformanceOutcome': {'name': 'hasConformanceOutcome',
                                                  'required': True}}})

    assessesCondition: str = Field(default=..., description="""The condition of the evaluation standard that is assessed.""", json_schema_extra = { "linkml_meta": {'domain_of': ['ConditionAssessment'], 'slot_uri': 'earl:test'} })
    hasConformanceOutcome: ConformanceOutcome = Field(default=..., description="""Whether the condition was fulfilled.""", json_schema_extra = { "linkml_meta": {'close_mappings': ['dpv:hasComplianceStatus'],
         'domain_of': ['ConditionAssessment'],
         'slot_uri': 'earl:outcome'} })
    evidence: Optional[str] = Field(default=None, description="""Notes or evidence supporting the answer, e.g. a link to a published policy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact', 'ConditionAssessment']} })
    justification: Optional[str] = Field(default=None, description="""Why a condition was not fulfilled, or how the same principle was achieved via alternative means.""", json_schema_extra = { "linkml_meta": {'domain_of': ['ConditionAssessment'],
         'related_mappings': ['earl:info'],
         'slot_uri': 'nexus:justification'} })
    disclosureAnswer: Optional[bool] = Field(default=None, description="""For disclosure conditions (e.g. AEF-1 2.4.x), whether the disclosed circumstance applies, e.g. true if the evaluator was paid by the system provider. Independent of whether the condition was fulfilled.""", json_schema_extra = { "linkml_meta": {'domain_of': ['ConditionAssessment'], 'slot_uri': 'nexus:disclosureAnswer'} })
    appliesToEvaluation: Optional[list[str]] = Field(default=None, description="""The evaluations of the engagement that this answer is specific to. When absent, the answer applies to the engagement as a whole.""", json_schema_extra = { "linkml_meta": {'domain_of': ['ConditionAssessment'], 'slot_uri': 'nexus:appliesToEvaluation'} })

ConformanceOutcome

Bases: str, Enum

The outcome of assessing a condition of an evaluation standard.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ConformanceOutcome(str, Enum):
    """
    The outcome of assessing a condition of an evaluation standard.
    """
    FULFILLED = "FULFILLED"
    """
    The condition was fulfilled.
    """
    NOT_FULFILLED = "NOT_FULFILLED"
    """
    The condition was not fulfilled.
    """
    ALTERNATIVE_MEANS = "ALTERNATIVE_MEANS"
    """
    The condition was not fulfilled literally, but the same principle was achieved via alternative means.
    """
    NOT_APPLICABLE = "NOT_APPLICABLE"
    """
    The condition does not apply to this engagement.
    """
    NOT_ASSESSED = "NOT_ASSESSED"
    """
    The condition was not assessed.
    """

ALTERNATIVE_MEANS = 'ALTERNATIVE_MEANS' class-attribute instance-attribute

The condition was not fulfilled literally, but the same principle was achieved via alternative means.

FULFILLED = 'FULFILLED' class-attribute instance-attribute

The condition was fulfilled.

NOT_APPLICABLE = 'NOT_APPLICABLE' class-attribute instance-attribute

The condition does not apply to this engagement.

NOT_ASSESSED = 'NOT_ASSESSED' class-attribute instance-attribute

The condition was not assessed.

NOT_FULFILLED = 'NOT_FULFILLED' class-attribute instance-attribute

The condition was not fulfilled.

Container

Bases: ConfiguredBaseModel

An umbrella object that holds the ontology class instances

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Container(ConfiguredBaseModel):
    """
    An umbrella object that holds the ontology class instances
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai-risk-ontology',
         'tree_root': True})

    organizations: Optional[list[Union[Organization,AiProvider,AiOffice]]] = Field(default=None, description="""A list of organizations""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    licenses: Optional[list[License]] = Field(default=None, description="""A list of licenses""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    modalities: Optional[list[Modality]] = Field(default=None, description="""A list of AI modalities""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    aitasks: Optional[list[AiTask]] = Field(default=None, description="""A list of AI tasks""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    documents: Optional[list[Documentation]] = Field(default=None, description="""A list of documents""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    datasets: Optional[list[Dataset]] = Field(default=None, description="""A list of data sets""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    llmintrinsics: Optional[list[LLMIntrinsic]] = Field(default=None, description="""A list of LLMIntrinsics""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    adapters: Optional[list[Adapter]] = Field(default=None, description="""A list of Adapters""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    taxonomies: Optional[list[Union[Taxonomy,RiskTaxonomy,RiskControlGroupTaxonomy,CapabilityTaxonomy,AiTaskTaxonomy]]] = Field(default=None, description="""A list of taxonomies""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    concepts: Optional[list[Union[Concept,RiskConcept,CapabilityConcept,CapabilityDomain,CapabilityGroup,Capability,RiskControlGroup,RiskGroup,Risk,RiskControl,RiskIncident,Impact,Action]]] = Field(default=None, description="""A list of concepts""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    entries: Optional[list[Union[Entry,Term,Principle,Certification,EvaluationStandard,LocalityOfUse,Risk,Capability,AiSystem,AiTask,Purpose,Domain,Adapter,LLMIntrinsic,AiAgent]]] = Field(default=None, description="""A list of entries""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    groups: Optional[list[Union[Group,RiskControlGroup,RiskGroup,CapabilityDomain,CapabilityGroup,AiTaskDomain,AiTaskGroup,StakeholderGroup]]] = Field(default=None, description="""A list of groups""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    vocabularies: Optional[list[Vocabulary]] = Field(default=None, description="""A list of vocabularies""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    controls: Optional[list[Union[Control,RiskControl,Action]]] = Field(default=None, description="""A list of AI controls""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    riskincidents: Optional[list[RiskIncident]] = Field(default=None, description="""A list of AI risk incidents""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    stakeholdergroups: Optional[list[StakeholderGroup]] = Field(default=None, description="""A list of AI stakeholder groups""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    stakeholders: Optional[list[Stakeholder]] = Field(default=None, description="""A list of stakeholders""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    actions: Optional[list[Action]] = Field(default=None, description="""A list of risk related actions""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    evaluations: Optional[list[AiEval]] = Field(default=None, description="""A list of AI evaluation methods""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    aievalresults: Optional[list[AiEvalResult]] = Field(default=None, description="""A list of AI evaluation results""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    benchmarkmetadatacards: Optional[list[BenchmarkMetadataCard]] = Field(default=None, description="""A list of AI evaluation benchmark metadata cards""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    aimodelfamilies: Optional[list[LargeLanguageModelFamily]] = Field(default=None, description="""A list of AI model families""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    aimodels: Optional[list[LargeLanguageModel]] = Field(default=None, description="""A list of AI models""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    policies: Optional[list[Union[Policy,LLMQuestionPolicy]]] = Field(default=None, description="""A list of policies""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    rules: Optional[list[Union[Rule,AttributeConditionRule,Permission,Prohibition,Obligation,Recommendation,ControlActivity,Requirement,ControlActivityPermission,ControlActivityProhibition,ControlActivityObligation,ControlActivityRecommendation]]] = Field(default=None, description="""A list of rules""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    prohibitions: Optional[list[Union[Prohibition,ControlActivityProhibition]]] = Field(default=None, description="""A list of prohibitions""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    permissions: Optional[list[Union[Permission,ControlActivityPermission]]] = Field(default=None, description="""A list of Permissions""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    obligations: Optional[list[Union[Obligation,ControlActivityObligation]]] = Field(default=None, description="""A list of Obligations""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })
    thirdpartyevaluationengagements: Optional[list[ThirdPartyEvaluationEngagement]] = Field(default=None, description="""A list of third-party evaluation engagements""", json_schema_extra = { "linkml_meta": {'domain_of': ['Container']} })

Control

Bases: Entity

A measure that maintains and/or modifies

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Control(Entity):
    """
    A measure that maintains and/or modifies
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'nexus:Control',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common',
         'mixin': True})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isApplicableinLocality: Optional[list[str]] = Field(default=None, description="""A relationship where an entity has is applicable in these localities.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Control', 'Policy'], 'slot_uri': 'nexus:isApplicableinLocality'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    type: Literal["Control"] = Field(default="Control", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ControlActivity

Bases: Rule

An obligation, permission, or prohibition for AI system assurance.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ControlActivity(Rule):
    """
    An obligation, permission, or prohibition for AI system assurance.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_aiuc', 'mixin': True})

    hasControlApplication: Optional[AIUC1ControlApplicationCategory] = Field(default=None, description="""Which of the AIUC-1 ControlApplicationCategory this control activity (rule) belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasControlApplication'} })
    hasEvidenceCategory: Optional[list[AIUC1EvidenceCategory]] = Field(default=None, description="""The evidence category, ie Technical Implementation, Operational Practices, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasEvidenceCategory'} })
    hasTypicalLocation: Optional[list[str]] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalLocation'} })
    isApplicableToCapability: Optional[list[str]] = Field(default=None, description="""This evidence only applies to AI systems with this capability""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:isApplicableToCapability'} })
    hasRequirement: Optional[str] = Field(default=None, description="""This requirement this rule belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasRequirement'} })
    hasRequirementType: Optional[AIUC1RequirementType] = Field(default=None, description="""The requirement type of whether this is preventive, detective, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:hasRequirementType'} })
    hasTypicalEvidence: Optional[str] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalEvidence'} })
    type: Literal["ControlActivity"] = Field(default="ControlActivity", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ControlActivityObligation

Bases: ControlActivity, Obligation

A control activity (rule) describing an obligation for performing an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ControlActivityObligation(ControlActivity, Obligation):
    """
    A control activity (rule) describing an obligation for performing an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:ControlActivityObligation',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_aiuc',
         'mixins': ['ControlActivity']})

    type: Literal["ControlActivityObligation"] = Field(default="ControlActivityObligation", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    hasControlApplication: Optional[AIUC1ControlApplicationCategory] = Field(default=None, description="""Which of the AIUC-1 ControlApplicationCategory this control activity (rule) belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasControlApplication'} })
    hasEvidenceCategory: Optional[list[AIUC1EvidenceCategory]] = Field(default=None, description="""The evidence category, ie Technical Implementation, Operational Practices, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasEvidenceCategory'} })
    hasTypicalLocation: Optional[list[str]] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalLocation'} })
    isApplicableToCapability: Optional[list[str]] = Field(default=None, description="""This evidence only applies to AI systems with this capability""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:isApplicableToCapability'} })
    hasRequirement: Optional[str] = Field(default=None, description="""This requirement this rule belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasRequirement'} })
    hasRequirementType: Optional[AIUC1RequirementType] = Field(default=None, description="""The requirement type of whether this is preventive, detective, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:hasRequirementType'} })
    hasTypicalEvidence: Optional[str] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalEvidence'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ControlActivityPermission

Bases: ControlActivity, Permission

A control activity (rule) describing a permission to perform an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ControlActivityPermission(ControlActivity, Permission):
    """
    A control activity (rule) describing a permission to perform an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:ControlActivityPermission',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_aiuc',
         'mixins': ['ControlActivity']})

    type: Literal["ControlActivityPermission"] = Field(default="ControlActivityPermission", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    hasControlApplication: Optional[AIUC1ControlApplicationCategory] = Field(default=None, description="""Which of the AIUC-1 ControlApplicationCategory this control activity (rule) belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasControlApplication'} })
    hasEvidenceCategory: Optional[list[AIUC1EvidenceCategory]] = Field(default=None, description="""The evidence category, ie Technical Implementation, Operational Practices, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasEvidenceCategory'} })
    hasTypicalLocation: Optional[list[str]] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalLocation'} })
    isApplicableToCapability: Optional[list[str]] = Field(default=None, description="""This evidence only applies to AI systems with this capability""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:isApplicableToCapability'} })
    hasRequirement: Optional[str] = Field(default=None, description="""This requirement this rule belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasRequirement'} })
    hasRequirementType: Optional[AIUC1RequirementType] = Field(default=None, description="""The requirement type of whether this is preventive, detective, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:hasRequirementType'} })
    hasTypicalEvidence: Optional[str] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalEvidence'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ControlActivityProhibition

Bases: ControlActivity, Prohibition

A control activity (rule) describing a prohibition to perform an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ControlActivityProhibition(ControlActivity, Prohibition):
    """
    A control activity (rule) describing a prohibition to perform an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:ControlActivityProhibition',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_aiuc',
         'mixins': ['ControlActivity']})

    type: Literal["ControlActivityProhibition"] = Field(default="ControlActivityProhibition", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    hasControlApplication: Optional[AIUC1ControlApplicationCategory] = Field(default=None, description="""Which of the AIUC-1 ControlApplicationCategory this control activity (rule) belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasControlApplication'} })
    hasEvidenceCategory: Optional[list[AIUC1EvidenceCategory]] = Field(default=None, description="""The evidence category, ie Technical Implementation, Operational Practices, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasEvidenceCategory'} })
    hasTypicalLocation: Optional[list[str]] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalLocation'} })
    isApplicableToCapability: Optional[list[str]] = Field(default=None, description="""This evidence only applies to AI systems with this capability""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:isApplicableToCapability'} })
    hasRequirement: Optional[str] = Field(default=None, description="""This requirement this rule belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasRequirement'} })
    hasRequirementType: Optional[AIUC1RequirementType] = Field(default=None, description="""The requirement type of whether this is preventive, detective, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:hasRequirementType'} })
    hasTypicalEvidence: Optional[str] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalEvidence'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ControlActivityRecommendation

Bases: ControlActivity, Recommendation

A control activity (rule) describing a recommendation for performing an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ControlActivityRecommendation(ControlActivity, Recommendation):
    """
    A control activity (rule) describing a recommendation for performing an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:ControlActivityRecommendation',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_aiuc',
         'mixins': ['ControlActivity']})

    type: Literal["ControlActivityRecommendation"] = Field(default="ControlActivityRecommendation", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    hasControlApplication: Optional[AIUC1ControlApplicationCategory] = Field(default=None, description="""Which of the AIUC-1 ControlApplicationCategory this control activity (rule) belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasControlApplication'} })
    hasEvidenceCategory: Optional[list[AIUC1EvidenceCategory]] = Field(default=None, description="""The evidence category, ie Technical Implementation, Operational Practices, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasEvidenceCategory'} })
    hasTypicalLocation: Optional[list[str]] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalLocation'} })
    isApplicableToCapability: Optional[list[str]] = Field(default=None, description="""This evidence only applies to AI systems with this capability""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:isApplicableToCapability'} })
    hasRequirement: Optional[str] = Field(default=None, description="""This requirement this rule belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasRequirement'} })
    hasRequirementType: Optional[AIUC1RequirementType] = Field(default=None, description="""The requirement type of whether this is preventive, detective, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:hasRequirementType'} })
    hasTypicalEvidence: Optional[str] = Field(default=None, description="""The evidence is usually found here""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity'],
         'slot_uri': 'nexus:hasTypicalEvidence'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

DataPreprocessing

Bases: AiLifecyclePhase

Data transformations, such as PI filtering, performed to ensure high quality of AI model training data.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class DataPreprocessing(AiLifecyclePhase):
    """
    Data transformations, such as PI filtering, performed to ensure high quality of AI model training data.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Dataset

Bases: Entity

A body of structured information describing some topic(s) of interest.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Dataset(Entity):
    """
    A body of structured information describing some topic(s) of interest.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'schema:Dataset',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    isProvidedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance that provides this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'schema:provider'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Documentation

Bases: Entity

Documented information about a concept or other topic(s) of interest.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Documentation(Entity):
    """
    Documented information about a concept or other topic(s) of interest.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'aliases': ['ExternalReference'],
         'class_uri': 'airo:Documentation',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common',
         'slot_usage': {'isCategorizedAs': {'description': 'The category this document '
                                                           'falls under, referenced as '
                                                           'a catalogued Term rather '
                                                           'than repeated as free '
                                                           'text, so grouping labels '
                                                           'are declared in one place.',
                                            'name': 'isCategorizedAs',
                                            'range': 'Term'}}})

    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })
    author: Optional[str] = Field(default=None, description="""The author or authors of the documentation""", json_schema_extra = { "linkml_meta": {'domain_of': ['Documentation', 'RiskIncident']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[str]] = Field(default=None, description="""The category this document falls under, referenced as a catalogued Term rather than repeated as free text, so grouping labels are declared in one place.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Domain

Bases: Entry

An area, sector, or industry that is associated with economic activities.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Domain(Entry):
    """
    An area, sector, or industry that is associated with economic activities.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:Domain',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Domain"] = Field(default="Domain", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Entity

Bases: ConfiguredBaseModel

A generic grouping for any identifiable entity.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Entity(ConfiguredBaseModel):
    """
    A generic grouping for any identifiable entity.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'schema:Thing',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common',
         'mixin': True})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Entry

Bases: Entity

An entry and its definitions.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Entry(Entity):
    """
    An entry and its definitions.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'nexus:Entry',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Entry"] = Field(default="Entry", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

EuAiRiskCategory

Bases: str, Enum

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class EuAiRiskCategory(str, Enum):
    EXCLUDED = "EXCLUDED"
    """
    Excluded
    """
    PROHIBITED = "PROHIBITED"
    """
    Prohibited
    """
    HIGH_RISK_EXCEPTION = "HIGH_RISK_EXCEPTION"
    """
    High-Risk Exception
    """
    HIGH_RISK = "HIGH_RISK"
    """
    High Risk
    """
    LIMITED_OR_LOW_RISK = "LIMITED_OR_LOW_RISK"
    """
    Limited or Low Risk
    """

EXCLUDED = 'EXCLUDED' class-attribute instance-attribute

Excluded

HIGH_RISK = 'HIGH_RISK' class-attribute instance-attribute

High Risk

HIGH_RISK_EXCEPTION = 'HIGH_RISK_EXCEPTION' class-attribute instance-attribute

High-Risk Exception

LIMITED_OR_LOW_RISK = 'LIMITED_OR_LOW_RISK' class-attribute instance-attribute

Limited or Low Risk

PROHIBITED = 'PROHIBITED' class-attribute instance-attribute

Prohibited

EvaluationResultRecord

Bases: Entity

A single evaluation result record

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class EvaluationResultRecord(Entity):
    """
    A single evaluation result record
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:evaluationresultrecord',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval'})

    hasSourceData: Optional[SourceData] = Field(default=None, description="""Source data information""", json_schema_extra = { "linkml_meta": {'domain': 'EvaluationResultRecord', 'domain_of': ['EvaluationResultRecord']} })
    hasMetricConfig: Optional[MetricConfig] = Field(default=None, description="""Metric configuration""", json_schema_extra = { "linkml_meta": {'domain': 'EvaluationResultRecord', 'domain_of': ['EvaluationResultRecord']} })
    hasScoreDetails: Optional[ScoreDetails] = Field(default=None, description="""Score details""", json_schema_extra = { "linkml_meta": {'domain': 'EvaluationResultRecord', 'domain_of': ['EvaluationResultRecord']} })
    evaluation_name: Optional[str] = Field(default=None, description="""Name of the evaluation benchmark""", json_schema_extra = { "linkml_meta": {'domain_of': ['EvaluationResultRecord']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

EvaluationStandard

Bases: Entry

A standard defining minimum conditions, processes, or independence criteria required for conducting AI evaluations

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class EvaluationStandard(Entry):
    """
    A standard defining minimum conditions, processes, or independence criteria required for conducting AI evaluations
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'dpv:ManagementStandard',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    hasPrinciple: Optional[list[str]] = Field(default=None, description="""The principle(s) this entry is composed of or belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['EvaluationStandard', 'Requirement'],
         'slot_uri': 'dpv:isPartOf'} })
    type: Literal["EvaluationStandard"] = Field(default="EvaluationStandard", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

EvaluationStandardConformance

Bases: ConfiguredBaseModel

A completed checklist reporting how an engagement addressed the conditions of an evaluation standard.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class EvaluationStandardConformance(ConfiguredBaseModel):
    """
    A completed checklist reporting how an engagement addressed the conditions of an evaluation standard.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:EvaluationStandardConformance',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'related_mappings': ['dpv:ComplianceStatus'],
         'slot_usage': {'conformsToStandard': {'name': 'conformsToStandard',
                                               'required': True}}})

    conformsToStandard: str = Field(default=..., description="""The evaluation standard the checklist is completed against.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EvaluationStandardConformance'],
         'slot_uri': 'dcterms:conformsTo'} })
    satisfiesAllRequirements: Optional[bool] = Field(default=None, description="""The overall answer to whether the engagement satisfies all the minimum requirements of the standard.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EvaluationStandardConformance'],
         'slot_uri': 'nexus:satisfiesAllRequirements'} })
    hasConditionAssessment: Optional[list[ConditionAssessment]] = Field(default=None, description="""The per-condition answers of a completed checklist.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EvaluationStandardConformance'],
         'slot_uri': 'nexus:hasConditionAssessment'} })

EveryEvalAIResult

Bases: AiEvalResult

An evaluation result from the Every Eval Ever dataset, capturing evaluation metadata and results from the EEE_datastore.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class EveryEvalAIResult(AiEvalResult):
    """
    An evaluation result from the Every Eval Ever dataset, capturing evaluation metadata and results from the EEE_datastore.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:everyevalairesult',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'slot_usage': {'hasRelatedRisk': {'domain': 'AiEvalResult',
                                           'name': 'hasRelatedRisk',
                                           'range': 'RiskConcept'}}})

    hasSourceMetadata: Optional[SourceMetadata] = Field(default=None, description="""Source metadata for the evaluation""", json_schema_extra = { "linkml_meta": {'domain': 'EveryEvalAIResult', 'domain_of': ['EveryEvalAIResult']} })
    hasModelInfo: Optional[ModelInfo] = Field(default=None, description="""Model information for the evaluation""", json_schema_extra = { "linkml_meta": {'domain': 'EveryEvalAIResult', 'domain_of': ['EveryEvalAIResult']} })
    hasEvaluationResults: Optional[dict[str, EvaluationResultRecord]] = Field(default=None, description="""Array of evaluation results""", json_schema_extra = { "linkml_meta": {'domain': 'EveryEvalAIResult', 'domain_of': ['EveryEvalAIResult']} })
    hasDataType: Optional[list[str]] = Field(default=None, description="""The type of data used in the benchmark (e.g., text, images, or multi-modal)""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDomains: Optional[list[str]] = Field(default=None, description="""The specific domains or areas where the benchmark is applied (e.g., natural language processing, computer vision).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasLanguages: Optional[list[str]] = Field(default=None, description="""The languages included in the dataset used by the benchmark (e.g., English, multilingual).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasTasks: Optional[list[str]] = Field(default=None, description="""The tasks or evaluations the benchmark is intended to assess.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval', 'EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDataSource: Optional[list[str]] = Field(default=None, description="""The origin or source of the data used in the benchmark (e.g., curated datasets, user submissions).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDataSize: Optional[str] = Field(default=None, description="""The size of the dataset, including the number of data points or examples.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDataFormat: Optional[list[str]] = Field(default=None, description="""The structure and modality of the data (e.g., sentence pairs, question-answer format, tabular data).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasMethods: Optional[list[str]] = Field(default=None, description="""The evaluation techniques applied within the benchmark.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasMetrics: Optional[list[str]] = Field(default=None, description="""The specific performance metrics used to assess models (e.g., accuracy, F1 score, precision, recall).""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasLimitations: Optional[list[str]] = Field(default=None, description="""Limitations in evaluating or addressing risks, such as gaps in demographic coverage or specific domains.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasGoal: Optional[str] = Field(default=None, description="""The specific goal or primary use case the benchmark is designed for.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasAudience: Optional[list[str]] = Field(default=None, description="""The intended audience, such as researchers, developers, policymakers, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasResources: Optional[list[str]] = Field(default=None, description="""Links to relevant resources, such as repositories or papers related to the benchmark.""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'AiEvalResult',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    schema_version: Optional[str] = Field(default=None, description="""Version of the evaluation schema""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult']} })
    evaluation_id: Optional[str] = Field(default=None, description="""Unique identifier for this evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult']} })
    evaluation_timestamp: Optional[datetime ] = Field(default=None, description="""ISO 8601 timestamp when evaluation was performed""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult']} })
    retrieved_timestamp: Optional[str] = Field(default=None, description="""Unix timestamp when the data was retrieved""", json_schema_extra = { "linkml_meta": {'domain_of': ['EveryEvalAIResult']} })
    isResultOf: Optional[str] = Field(default=None, description="""A relationship indicating that an entity is the result of an AI evaluation.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEvalResult'], 'slot_uri': 'dqv:isMeasurementOf'} })
    value: str = Field(default=..., description="""Some numeric or string value""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact']} })
    evidence: Optional[str] = Field(default=None, description="""Evidence provides a source (typical a chunk, paragraph or link) describing where some value was found or how it was generated.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact', 'ConditionAssessment']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Fact

Bases: ConfiguredBaseModel

A fact about something, for example the result of a measurement. In addition to the value, evidence is provided.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Fact(ConfiguredBaseModel):
    """
    A fact about something, for example the result of a measurement. In addition to the value, evidence is provided.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'schema:Statement',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    value: str = Field(default=..., description="""Some numeric or string value""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact']} })
    evidence: Optional[str] = Field(default=None, description="""Evidence provides a source (typical a chunk, paragraph or link) describing where some value was found or how it was generated.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Fact', 'ConditionAssessment']} })

Group

Bases: Entity

Labelled groups of concepts.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Group(Entity):
    """
    Labelled groups of concepts.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'skos:Collection',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common',
         'mixin': True})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasPart: Optional[list[str]] = Field(default=None, description="""A relationship where an entity has another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group',
                       'RiskControlGroup',
                       'RiskGroup',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup'],
         'slot_uri': 'skos:member'} })
    belongsToDomain: Optional[Any] = Field(default=None, description="""A relationship where a group belongs to a domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group', 'CapabilityGroup'], 'slot_uri': 'schema:isPartOf'} })
    type: Literal["Group"] = Field(default="Group", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement'],
         'ifabsent': 'string(Group)'} })
    narrower: Optional[list[str]] = Field(default=None, description="""Related concepts that are narrower in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    broader: Optional[list[str]] = Field(default=None, description="""Related concepts that are broader in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Input

Bases: Entity

Input for which the system or component generates output.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Input(Entity):
    """
    Input for which the system or component generates output.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:Input',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Jurisdiction

Bases: str, Enum

ISO 3166-1 alpha-2 country code, from the DPV Location vocabulary (https://w3id.org/dpv/loc). Values are members of dpv:Country.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Jurisdiction(str, Enum):
    """
    ISO 3166-1 alpha-2 country code, from the DPV Location vocabulary (https://w3id.org/dpv/loc). Values are members of dpv:Country.
    """
    AD = "AD"
    """
    Andorra
    """
    AE = "AE"
    """
    United Arab Emirates
    """
    AF = "AF"
    """
    Afghanistan
    """
    AG = "AG"
    """
    Antigua and Barbuda
    """
    AI = "AI"
    """
    Anguilla
    """
    AL = "AL"
    """
    Albania
    """
    AM = "AM"
    """
    Armenia
    """
    AO = "AO"
    """
    Angola
    """
    AQ = "AQ"
    """
    Antarctica
    """
    AR = "AR"
    """
    Argentina
    """
    AS = "AS"
    """
    American Samoa
    """
    AT = "AT"
    """
    Austria
    """
    AU = "AU"
    """
    Australia
    """
    AW = "AW"
    """
    Aruba
    """
    AX = "AX"
    """
    Åland Islands
    """
    AZ = "AZ"
    """
    Azerbaijan
    """
    BA = "BA"
    """
    Bosnia and Herzegovina
    """
    BB = "BB"
    """
    Barbados
    """
    BD = "BD"
    """
    Bangladesh
    """
    BE = "BE"
    """
    Belgium
    """
    BF = "BF"
    """
    Burkina Faso
    """
    BG = "BG"
    """
    Bulgaria
    """
    BH = "BH"
    """
    Bahrain
    """
    BI = "BI"
    """
    Burundi
    """
    BJ = "BJ"
    """
    Benin
    """
    BL = "BL"
    """
    Saint Barthélemy
    """
    BM = "BM"
    """
    Bermuda
    """
    BN = "BN"
    """
    Brunei Darussalam
    """
    BO = "BO"
    """
    Bolivia (Plurinational State of)
    """
    BQ = "BQ"
    """
    Bonaire, Sint Eustatius and Saba
    """
    BR = "BR"
    """
    Brazil
    """
    BS = "BS"
    """
    Bahamas
    """
    BT = "BT"
    """
    Bhutan
    """
    BV = "BV"
    """
    Bouvet Island
    """
    BW = "BW"
    """
    Botswana
    """
    BY = "BY"
    """
    Belarus
    """
    BZ = "BZ"
    """
    Belize
    """
    CA = "CA"
    """
    Canada
    """
    CC = "CC"
    """
    Cocos (Keeling) Islands
    """
    CD = "CD"
    """
    Democratic Republic of the Congo
    """
    CF = "CF"
    """
    Central African Republic
    """
    CG = "CG"
    """
    Congo
    """
    CH = "CH"
    """
    Switzerland
    """
    CI = "CI"
    """
    Côte d’Ivoire
    """
    CK = "CK"
    """
    Cook Islands
    """
    CL = "CL"
    """
    Chile
    """
    CM = "CM"
    """
    Cameroon
    """
    CN = "CN"
    """
    China
    """
    CO = "CO"
    """
    Colombia
    """
    CR = "CR"
    """
    Costa Rica
    """
    CU = "CU"
    """
    Cuba
    """
    CV = "CV"
    """
    Cabo Verde
    """
    CW = "CW"
    """
    Curaçao
    """
    CX = "CX"
    """
    Christmas Island
    """
    CY = "CY"
    """
    Cyprus
    """
    CZ = "CZ"
    """
    Czechia
    """
    DE = "DE"
    """
    Germany
    """
    DJ = "DJ"
    """
    Djibouti
    """
    DK = "DK"
    """
    Denmark
    """
    DM = "DM"
    """
    Dominica
    """
    DO = "DO"
    """
    Dominican Republic
    """
    DZ = "DZ"
    """
    Algeria
    """
    EC = "EC"
    """
    Ecuador
    """
    EE = "EE"
    """
    Estonia
    """
    EG = "EG"
    """
    Egypt
    """
    EH = "EH"
    """
    Western Sahara
    """
    ER = "ER"
    """
    Eritrea
    """
    ES = "ES"
    """
    Spain
    """
    ET = "ET"
    """
    Ethiopia
    """
    FI = "FI"
    """
    Finland
    """
    FJ = "FJ"
    """
    Fiji
    """
    FK = "FK"
    """
    Falkland Islands (Malvinas)
    """
    FM = "FM"
    """
    Micronesia (Federated States of)
    """
    FO = "FO"
    """
    Faroe Islands
    """
    FR = "FR"
    """
    France
    """
    GA = "GA"
    """
    Gabon
    """
    GB = "GB"
    """
    United Kingdom of Great Britain and Northern Ireland
    """
    GD = "GD"
    """
    Grenada
    """
    GE = "GE"
    """
    Georgia
    """
    GF = "GF"
    """
    French Guiana
    """
    GG = "GG"
    """
    Guernsey
    """
    GH = "GH"
    """
    Ghana
    """
    GI = "GI"
    """
    Gibraltar
    """
    GL = "GL"
    """
    Greenland
    """
    GM = "GM"
    """
    Gambia
    """
    GN = "GN"
    """
    Guinea
    """
    GP = "GP"
    """
    Guadeloupe
    """
    GQ = "GQ"
    """
    Equatorial Guinea
    """
    GR = "GR"
    """
    Greece
    """
    GS = "GS"
    """
    South Georgia and the South Sandwich Islands
    """
    GT = "GT"
    """
    Guatemala
    """
    GU = "GU"
    """
    Guam
    """
    GW = "GW"
    """
    Guinea-Bissau
    """
    GY = "GY"
    """
    Guyana
    """
    HK = "HK"
    """
    China, Hong Kong Special Administrative Region
    """
    HM = "HM"
    """
    Heard Island and McDonald Islands
    """
    HN = "HN"
    """
    Honduras
    """
    HR = "HR"
    """
    Croatia
    """
    HT = "HT"
    """
    Haiti
    """
    HU = "HU"
    """
    Hungary
    """
    ID = "ID"
    """
    Indonesia
    """
    IE = "IE"
    """
    Ireland
    """
    IL = "IL"
    """
    Israel
    """
    IM = "IM"
    """
    Isle of Man
    """
    IN = "IN"
    """
    India
    """
    IO = "IO"
    """
    British Indian Ocean Territory
    """
    IQ = "IQ"
    """
    Iraq
    """
    IR = "IR"
    """
    Iran (Islamic Republic of)
    """
    IS = "IS"
    """
    Iceland
    """
    IT = "IT"
    """
    Italy
    """
    JE = "JE"
    """
    Jersey
    """
    JM = "JM"
    """
    Jamaica
    """
    JO = "JO"
    """
    Jordan
    """
    JP = "JP"
    """
    Japan
    """
    KE = "KE"
    """
    Kenya
    """
    KG = "KG"
    """
    Kyrgyzstan
    """
    KH = "KH"
    """
    Cambodia
    """
    KI = "KI"
    """
    Kiribati
    """
    KM = "KM"
    """
    Comoros
    """
    KN = "KN"
    """
    Saint Kitts and Nevis
    """
    KP = "KP"
    """
    Democratic People's Republic of Korea
    """
    KR = "KR"
    """
    Republic of Korea
    """
    KW = "KW"
    """
    Kuwait
    """
    KY = "KY"
    """
    Cayman Islands
    """
    KZ = "KZ"
    """
    Kazakhstan
    """
    LA = "LA"
    """
    Lao People's Democratic Republic
    """
    LB = "LB"
    """
    Lebanon
    """
    LC = "LC"
    """
    Saint Lucia
    """
    LI = "LI"
    """
    Liechtenstein
    """
    LK = "LK"
    """
    Sri Lanka
    """
    LR = "LR"
    """
    Liberia
    """
    LS = "LS"
    """
    Lesotho
    """
    LT = "LT"
    """
    Lithuania
    """
    LU = "LU"
    """
    Luxembourg
    """
    LV = "LV"
    """
    Latvia
    """
    LY = "LY"
    """
    Libya
    """
    MA = "MA"
    """
    Morocco
    """
    MC = "MC"
    """
    Monaco
    """
    MD = "MD"
    """
    Republic of Moldova
    """
    ME = "ME"
    """
    Montenegro
    """
    MF = "MF"
    """
    Saint Martin (French Part)
    """
    MG = "MG"
    """
    Madagascar
    """
    MH = "MH"
    """
    Marshall Islands
    """
    MK = "MK"
    """
    North Macedonia
    """
    ML = "ML"
    """
    Mali
    """
    MM = "MM"
    """
    Myanmar
    """
    MN = "MN"
    """
    Mongolia
    """
    MO = "MO"
    """
    China, Macao Special Administrative Region
    """
    MP = "MP"
    """
    Northern Mariana Islands
    """
    MQ = "MQ"
    """
    Martinique
    """
    MR = "MR"
    """
    Mauritania
    """
    MS = "MS"
    """
    Montserrat
    """
    MT = "MT"
    """
    Malta
    """
    MU = "MU"
    """
    Mauritius
    """
    MV = "MV"
    """
    Maldives
    """
    MW = "MW"
    """
    Malawi
    """
    MX = "MX"
    """
    Mexico
    """
    MY = "MY"
    """
    Malaysia
    """
    MZ = "MZ"
    """
    Mozambique
    """
    NA = "NA"
    """
    Namibia
    """
    NC = "NC"
    """
    New Caledonia
    """
    NE = "NE"
    """
    Niger
    """
    NF = "NF"
    """
    Norfolk Island
    """
    NG = "NG"
    """
    Nigeria
    """
    NI = "NI"
    """
    Nicaragua
    """
    NL = "NL"
    """
    Netherlands
    """
    NO = "NO"
    """
    Norway
    """
    NP = "NP"
    """
    Nepal
    """
    NR = "NR"
    """
    Nauru
    """
    NU = "NU"
    """
    Niue
    """
    NZ = "NZ"
    """
    New Zealand
    """
    OM = "OM"
    """
    Oman
    """
    PA = "PA"
    """
    Panama
    """
    PE = "PE"
    """
    Peru
    """
    PF = "PF"
    """
    French Polynesia
    """
    PG = "PG"
    """
    Papua New Guinea
    """
    PH = "PH"
    """
    Philippines
    """
    PK = "PK"
    """
    Pakistan
    """
    PL = "PL"
    """
    Poland
    """
    PM = "PM"
    """
    Saint Pierre and Miquelon
    """
    PN = "PN"
    """
    Pitcairn
    """
    PR = "PR"
    """
    Puerto Rico
    """
    PS = "PS"
    """
    State of Palestine
    """
    PT = "PT"
    """
    Portugal
    """
    PW = "PW"
    """
    Palau
    """
    PY = "PY"
    """
    Paraguay
    """
    QA = "QA"
    """
    Qatar
    """
    RE = "RE"
    """
    Réunion
    """
    RO = "RO"
    """
    Romania
    """
    RS = "RS"
    """
    Serbia
    """
    RU = "RU"
    """
    Russian Federation
    """
    RW = "RW"
    """
    Rwanda
    """
    SA = "SA"
    """
    Saudi Arabia
    """
    SB = "SB"
    """
    Solomon Islands
    """
    SC = "SC"
    """
    Seychelles
    """
    SD = "SD"
    """
    Sudan
    """
    SE = "SE"
    """
    Sweden
    """
    SG = "SG"
    """
    Singapore
    """
    SH = "SH"
    """
    Saint Helena
    """
    SI = "SI"
    """
    Slovenia
    """
    SJ = "SJ"
    """
    Svalbard and Jan Mayen Islands
    """
    SK = "SK"
    """
    Slovakia
    """
    SL = "SL"
    """
    Sierra Leone
    """
    SM = "SM"
    """
    San Marino
    """
    SN = "SN"
    """
    Senegal
    """
    SO = "SO"
    """
    Somalia
    """
    SR = "SR"
    """
    Suriname
    """
    SS = "SS"
    """
    South Sudan
    """
    ST = "ST"
    """
    Sao Tome and Principe
    """
    SV = "SV"
    """
    El Salvador
    """
    SX = "SX"
    """
    Sint Maarten (Dutch part)
    """
    SY = "SY"
    """
    Syrian Arab Republic
    """
    SZ = "SZ"
    """
    Eswatini
    """
    TC = "TC"
    """
    Turks and Caicos Islands
    """
    TD = "TD"
    """
    Chad
    """
    TF = "TF"
    """
    French Southern Territories
    """
    TG = "TG"
    """
    Togo
    """
    TH = "TH"
    """
    Thailand
    """
    TJ = "TJ"
    """
    Tajikistan
    """
    TK = "TK"
    """
    Tokelau
    """
    TL = "TL"
    """
    Timor-Leste
    """
    TM = "TM"
    """
    Turkmenistan
    """
    TN = "TN"
    """
    Tunisia
    """
    TO = "TO"
    """
    Tonga
    """
    TR = "TR"
    """
    Turkey
    """
    TT = "TT"
    """
    Trinidad and Tobago
    """
    TV = "TV"
    """
    Tuvalu
    """
    TW = "TW"
    """
    Taiwan (Province of China)
    """
    TZ = "TZ"
    """
    United Republic of Tanzania
    """
    UA = "UA"
    """
    Ukraine
    """
    UG = "UG"
    """
    Uganda
    """
    UM = "UM"
    """
    United States Minor Outlying Islands
    """
    US = "US"
    """
    United States of America
    """
    UY = "UY"
    """
    Uruguay
    """
    UZ = "UZ"
    """
    Uzbekistan
    """
    VA = "VA"
    """
    Holy See
    """
    VC = "VC"
    """
    Saint Vincent and the Grenadines
    """
    VE = "VE"
    """
    Venezuela (Bolivarian Republic of)
    """
    VG = "VG"
    """
    British Virgin Islands
    """
    VI = "VI"
    """
    United States Virgin Islands
    """
    VN = "VN"
    """
    Viet Nam
    """
    VU = "VU"
    """
    Vanuatu
    """
    WF = "WF"
    """
    Wallis and Futuna Islands
    """
    WS = "WS"
    """
    Samoa
    """
    YE = "YE"
    """
    Yemen
    """
    YT = "YT"
    """
    Mayotte
    """
    ZA = "ZA"
    """
    South Africa
    """
    ZM = "ZM"
    """
    Zambia
    """
    ZW = "ZW"
    """
    Zimbabwe
    """

AD = 'AD' class-attribute instance-attribute

Andorra

AE = 'AE' class-attribute instance-attribute

United Arab Emirates

AF = 'AF' class-attribute instance-attribute

Afghanistan

AG = 'AG' class-attribute instance-attribute

Antigua and Barbuda

AI = 'AI' class-attribute instance-attribute

Anguilla

AL = 'AL' class-attribute instance-attribute

Albania

AM = 'AM' class-attribute instance-attribute

Armenia

AO = 'AO' class-attribute instance-attribute

Angola

AQ = 'AQ' class-attribute instance-attribute

Antarctica

AR = 'AR' class-attribute instance-attribute

Argentina

AS = 'AS' class-attribute instance-attribute

American Samoa

AT = 'AT' class-attribute instance-attribute

Austria

AU = 'AU' class-attribute instance-attribute

Australia

AW = 'AW' class-attribute instance-attribute

Aruba

AX = 'AX' class-attribute instance-attribute

Åland Islands

AZ = 'AZ' class-attribute instance-attribute

Azerbaijan

BA = 'BA' class-attribute instance-attribute

Bosnia and Herzegovina

BB = 'BB' class-attribute instance-attribute

Barbados

BD = 'BD' class-attribute instance-attribute

Bangladesh

BE = 'BE' class-attribute instance-attribute

Belgium

BF = 'BF' class-attribute instance-attribute

Burkina Faso

BG = 'BG' class-attribute instance-attribute

Bulgaria

BH = 'BH' class-attribute instance-attribute

Bahrain

BI = 'BI' class-attribute instance-attribute

Burundi

BJ = 'BJ' class-attribute instance-attribute

Benin

BL = 'BL' class-attribute instance-attribute

Saint Barthélemy

BM = 'BM' class-attribute instance-attribute

Bermuda

BN = 'BN' class-attribute instance-attribute

Brunei Darussalam

BO = 'BO' class-attribute instance-attribute

Bolivia (Plurinational State of)

BQ = 'BQ' class-attribute instance-attribute

Bonaire, Sint Eustatius and Saba

BR = 'BR' class-attribute instance-attribute

Brazil

BS = 'BS' class-attribute instance-attribute

Bahamas

BT = 'BT' class-attribute instance-attribute

Bhutan

BV = 'BV' class-attribute instance-attribute

Bouvet Island

BW = 'BW' class-attribute instance-attribute

Botswana

BY = 'BY' class-attribute instance-attribute

Belarus

BZ = 'BZ' class-attribute instance-attribute

Belize

CA = 'CA' class-attribute instance-attribute

Canada

CC = 'CC' class-attribute instance-attribute

Cocos (Keeling) Islands

CD = 'CD' class-attribute instance-attribute

Democratic Republic of the Congo

CF = 'CF' class-attribute instance-attribute

Central African Republic

CG = 'CG' class-attribute instance-attribute

Congo

CH = 'CH' class-attribute instance-attribute

Switzerland

CI = 'CI' class-attribute instance-attribute

Côte d’Ivoire

CK = 'CK' class-attribute instance-attribute

Cook Islands

CL = 'CL' class-attribute instance-attribute

Chile

CM = 'CM' class-attribute instance-attribute

Cameroon

CN = 'CN' class-attribute instance-attribute

China

CO = 'CO' class-attribute instance-attribute

Colombia

CR = 'CR' class-attribute instance-attribute

Costa Rica

CU = 'CU' class-attribute instance-attribute

Cuba

CV = 'CV' class-attribute instance-attribute

Cabo Verde

CW = 'CW' class-attribute instance-attribute

Curaçao

CX = 'CX' class-attribute instance-attribute

Christmas Island

CY = 'CY' class-attribute instance-attribute

Cyprus

CZ = 'CZ' class-attribute instance-attribute

Czechia

DE = 'DE' class-attribute instance-attribute

Germany

DJ = 'DJ' class-attribute instance-attribute

Djibouti

DK = 'DK' class-attribute instance-attribute

Denmark

DM = 'DM' class-attribute instance-attribute

Dominica

DO = 'DO' class-attribute instance-attribute

Dominican Republic

DZ = 'DZ' class-attribute instance-attribute

Algeria

EC = 'EC' class-attribute instance-attribute

Ecuador

EE = 'EE' class-attribute instance-attribute

Estonia

EG = 'EG' class-attribute instance-attribute

Egypt

EH = 'EH' class-attribute instance-attribute

Western Sahara

ER = 'ER' class-attribute instance-attribute

Eritrea

ES = 'ES' class-attribute instance-attribute

Spain

ET = 'ET' class-attribute instance-attribute

Ethiopia

FI = 'FI' class-attribute instance-attribute

Finland

FJ = 'FJ' class-attribute instance-attribute

Fiji

FK = 'FK' class-attribute instance-attribute

Falkland Islands (Malvinas)

FM = 'FM' class-attribute instance-attribute

Micronesia (Federated States of)

FO = 'FO' class-attribute instance-attribute

Faroe Islands

FR = 'FR' class-attribute instance-attribute

France

GA = 'GA' class-attribute instance-attribute

Gabon

GB = 'GB' class-attribute instance-attribute

United Kingdom of Great Britain and Northern Ireland

GD = 'GD' class-attribute instance-attribute

Grenada

GE = 'GE' class-attribute instance-attribute

Georgia

GF = 'GF' class-attribute instance-attribute

French Guiana

GG = 'GG' class-attribute instance-attribute

Guernsey

GH = 'GH' class-attribute instance-attribute

Ghana

GI = 'GI' class-attribute instance-attribute

Gibraltar

GL = 'GL' class-attribute instance-attribute

Greenland

GM = 'GM' class-attribute instance-attribute

Gambia

GN = 'GN' class-attribute instance-attribute

Guinea

GP = 'GP' class-attribute instance-attribute

Guadeloupe

GQ = 'GQ' class-attribute instance-attribute

Equatorial Guinea

GR = 'GR' class-attribute instance-attribute

Greece

GS = 'GS' class-attribute instance-attribute

South Georgia and the South Sandwich Islands

GT = 'GT' class-attribute instance-attribute

Guatemala

GU = 'GU' class-attribute instance-attribute

Guam

GW = 'GW' class-attribute instance-attribute

Guinea-Bissau

GY = 'GY' class-attribute instance-attribute

Guyana

HK = 'HK' class-attribute instance-attribute

China, Hong Kong Special Administrative Region

HM = 'HM' class-attribute instance-attribute

Heard Island and McDonald Islands

HN = 'HN' class-attribute instance-attribute

Honduras

HR = 'HR' class-attribute instance-attribute

Croatia

HT = 'HT' class-attribute instance-attribute

Haiti

HU = 'HU' class-attribute instance-attribute

Hungary

ID = 'ID' class-attribute instance-attribute

Indonesia

IE = 'IE' class-attribute instance-attribute

Ireland

IL = 'IL' class-attribute instance-attribute

Israel

IM = 'IM' class-attribute instance-attribute

Isle of Man

IN = 'IN' class-attribute instance-attribute

India

IO = 'IO' class-attribute instance-attribute

British Indian Ocean Territory

IQ = 'IQ' class-attribute instance-attribute

Iraq

IR = 'IR' class-attribute instance-attribute

Iran (Islamic Republic of)

IS = 'IS' class-attribute instance-attribute

Iceland

IT = 'IT' class-attribute instance-attribute

Italy

JE = 'JE' class-attribute instance-attribute

Jersey

JM = 'JM' class-attribute instance-attribute

Jamaica

JO = 'JO' class-attribute instance-attribute

Jordan

JP = 'JP' class-attribute instance-attribute

Japan

KE = 'KE' class-attribute instance-attribute

Kenya

KG = 'KG' class-attribute instance-attribute

Kyrgyzstan

KH = 'KH' class-attribute instance-attribute

Cambodia

KI = 'KI' class-attribute instance-attribute

Kiribati

KM = 'KM' class-attribute instance-attribute

Comoros

KN = 'KN' class-attribute instance-attribute

Saint Kitts and Nevis

KP = 'KP' class-attribute instance-attribute

Democratic People's Republic of Korea

KR = 'KR' class-attribute instance-attribute

Republic of Korea

KW = 'KW' class-attribute instance-attribute

Kuwait

KY = 'KY' class-attribute instance-attribute

Cayman Islands

KZ = 'KZ' class-attribute instance-attribute

Kazakhstan

LA = 'LA' class-attribute instance-attribute

Lao People's Democratic Republic

LB = 'LB' class-attribute instance-attribute

Lebanon

LC = 'LC' class-attribute instance-attribute

Saint Lucia

LI = 'LI' class-attribute instance-attribute

Liechtenstein

LK = 'LK' class-attribute instance-attribute

Sri Lanka

LR = 'LR' class-attribute instance-attribute

Liberia

LS = 'LS' class-attribute instance-attribute

Lesotho

LT = 'LT' class-attribute instance-attribute

Lithuania

LU = 'LU' class-attribute instance-attribute

Luxembourg

LV = 'LV' class-attribute instance-attribute

Latvia

LY = 'LY' class-attribute instance-attribute

Libya

MA = 'MA' class-attribute instance-attribute

Morocco

MC = 'MC' class-attribute instance-attribute

Monaco

MD = 'MD' class-attribute instance-attribute

Republic of Moldova

ME = 'ME' class-attribute instance-attribute

Montenegro

MF = 'MF' class-attribute instance-attribute

Saint Martin (French Part)

MG = 'MG' class-attribute instance-attribute

Madagascar

MH = 'MH' class-attribute instance-attribute

Marshall Islands

MK = 'MK' class-attribute instance-attribute

North Macedonia

ML = 'ML' class-attribute instance-attribute

Mali

MM = 'MM' class-attribute instance-attribute

Myanmar

MN = 'MN' class-attribute instance-attribute

Mongolia

MO = 'MO' class-attribute instance-attribute

China, Macao Special Administrative Region

MP = 'MP' class-attribute instance-attribute

Northern Mariana Islands

MQ = 'MQ' class-attribute instance-attribute

Martinique

MR = 'MR' class-attribute instance-attribute

Mauritania

MS = 'MS' class-attribute instance-attribute

Montserrat

MT = 'MT' class-attribute instance-attribute

Malta

MU = 'MU' class-attribute instance-attribute

Mauritius

MV = 'MV' class-attribute instance-attribute

Maldives

MW = 'MW' class-attribute instance-attribute

Malawi

MX = 'MX' class-attribute instance-attribute

Mexico

MY = 'MY' class-attribute instance-attribute

Malaysia

MZ = 'MZ' class-attribute instance-attribute

Mozambique

NA = 'NA' class-attribute instance-attribute

Namibia

NC = 'NC' class-attribute instance-attribute

New Caledonia

NE = 'NE' class-attribute instance-attribute

Niger

NF = 'NF' class-attribute instance-attribute

Norfolk Island

NG = 'NG' class-attribute instance-attribute

Nigeria

NI = 'NI' class-attribute instance-attribute

Nicaragua

NL = 'NL' class-attribute instance-attribute

Netherlands

NO = 'NO' class-attribute instance-attribute

Norway

NP = 'NP' class-attribute instance-attribute

Nepal

NR = 'NR' class-attribute instance-attribute

Nauru

NU = 'NU' class-attribute instance-attribute

Niue

NZ = 'NZ' class-attribute instance-attribute

New Zealand

OM = 'OM' class-attribute instance-attribute

Oman

PA = 'PA' class-attribute instance-attribute

Panama

PE = 'PE' class-attribute instance-attribute

Peru

PF = 'PF' class-attribute instance-attribute

French Polynesia

PG = 'PG' class-attribute instance-attribute

Papua New Guinea

PH = 'PH' class-attribute instance-attribute

Philippines

PK = 'PK' class-attribute instance-attribute

Pakistan

PL = 'PL' class-attribute instance-attribute

Poland

PM = 'PM' class-attribute instance-attribute

Saint Pierre and Miquelon

PN = 'PN' class-attribute instance-attribute

Pitcairn

PR = 'PR' class-attribute instance-attribute

Puerto Rico

PS = 'PS' class-attribute instance-attribute

State of Palestine

PT = 'PT' class-attribute instance-attribute

Portugal

PW = 'PW' class-attribute instance-attribute

Palau

PY = 'PY' class-attribute instance-attribute

Paraguay

QA = 'QA' class-attribute instance-attribute

Qatar

RE = 'RE' class-attribute instance-attribute

Réunion

RO = 'RO' class-attribute instance-attribute

Romania

RS = 'RS' class-attribute instance-attribute

Serbia

RU = 'RU' class-attribute instance-attribute

Russian Federation

RW = 'RW' class-attribute instance-attribute

Rwanda

SA = 'SA' class-attribute instance-attribute

Saudi Arabia

SB = 'SB' class-attribute instance-attribute

Solomon Islands

SC = 'SC' class-attribute instance-attribute

Seychelles

SD = 'SD' class-attribute instance-attribute

Sudan

SE = 'SE' class-attribute instance-attribute

Sweden

SG = 'SG' class-attribute instance-attribute

Singapore

SH = 'SH' class-attribute instance-attribute

Saint Helena

SI = 'SI' class-attribute instance-attribute

Slovenia

SJ = 'SJ' class-attribute instance-attribute

Svalbard and Jan Mayen Islands

SK = 'SK' class-attribute instance-attribute

Slovakia

SL = 'SL' class-attribute instance-attribute

Sierra Leone

SM = 'SM' class-attribute instance-attribute

San Marino

SN = 'SN' class-attribute instance-attribute

Senegal

SO = 'SO' class-attribute instance-attribute

Somalia

SR = 'SR' class-attribute instance-attribute

Suriname

SS = 'SS' class-attribute instance-attribute

South Sudan

ST = 'ST' class-attribute instance-attribute

Sao Tome and Principe

SV = 'SV' class-attribute instance-attribute

El Salvador

SX = 'SX' class-attribute instance-attribute

Sint Maarten (Dutch part)

SY = 'SY' class-attribute instance-attribute

Syrian Arab Republic

SZ = 'SZ' class-attribute instance-attribute

Eswatini

TC = 'TC' class-attribute instance-attribute

Turks and Caicos Islands

TD = 'TD' class-attribute instance-attribute

Chad

TF = 'TF' class-attribute instance-attribute

French Southern Territories

TG = 'TG' class-attribute instance-attribute

Togo

TH = 'TH' class-attribute instance-attribute

Thailand

TJ = 'TJ' class-attribute instance-attribute

Tajikistan

TK = 'TK' class-attribute instance-attribute

Tokelau

TL = 'TL' class-attribute instance-attribute

Timor-Leste

TM = 'TM' class-attribute instance-attribute

Turkmenistan

TN = 'TN' class-attribute instance-attribute

Tunisia

TO = 'TO' class-attribute instance-attribute

Tonga

TR = 'TR' class-attribute instance-attribute

Turkey

TT = 'TT' class-attribute instance-attribute

Trinidad and Tobago

TV = 'TV' class-attribute instance-attribute

Tuvalu

TW = 'TW' class-attribute instance-attribute

Taiwan (Province of China)

TZ = 'TZ' class-attribute instance-attribute

United Republic of Tanzania

UA = 'UA' class-attribute instance-attribute

Ukraine

UG = 'UG' class-attribute instance-attribute

Uganda

UM = 'UM' class-attribute instance-attribute

United States Minor Outlying Islands

US = 'US' class-attribute instance-attribute

United States of America

UY = 'UY' class-attribute instance-attribute

Uruguay

UZ = 'UZ' class-attribute instance-attribute

Uzbekistan

VA = 'VA' class-attribute instance-attribute

Holy See

VC = 'VC' class-attribute instance-attribute

Saint Vincent and the Grenadines

VE = 'VE' class-attribute instance-attribute

Venezuela (Bolivarian Republic of)

VG = 'VG' class-attribute instance-attribute

British Virgin Islands

VI = 'VI' class-attribute instance-attribute

United States Virgin Islands

VN = 'VN' class-attribute instance-attribute

Viet Nam

VU = 'VU' class-attribute instance-attribute

Vanuatu

WF = 'WF' class-attribute instance-attribute

Wallis and Futuna Islands

WS = 'WS' class-attribute instance-attribute

Samoa

YE = 'YE' class-attribute instance-attribute

Yemen

YT = 'YT' class-attribute instance-attribute

Mayotte

ZA = 'ZA' class-attribute instance-attribute

South Africa

ZM = 'ZM' class-attribute instance-attribute

Zambia

ZW = 'ZW' class-attribute instance-attribute

Zimbabwe

LLMIntrinsic

Bases: Entry

A capability that can be invoked through a well-defined API that is reasonably stable and independent of how the LLM intrinsic itself is implemented.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class LLMIntrinsic(Entry):
    """
    A capability that can be invoked through a well-defined API that is reasonably stable and independent of how the LLM intrinsic itself is implemented.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'ai:Capability',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_intrinsic',
         'slot_usage': {'hasRelatedRisk': {'domain': 'LLMIntrinsic',
                                           'name': 'hasRelatedRisk',
                                           'range': 'RiskConcept'},
                        'implementsCapability': {'domain': 'LLMIntrinsic',
                                                 'inverse': 'implementedByIntrinsic',
                                                 'name': 'implementsCapability',
                                                 'range': 'Capability'}}})

    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'LLMIntrinsic',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    hasRelatedTerm: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a term""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'RiskConcept'}, {'range': 'Term'}],
         'domain': 'Any',
         'domain_of': ['LLMIntrinsic']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasAdapter: Optional[list[str]] = Field(default=None, description="""The Adapter for the intrinsic""", json_schema_extra = { "linkml_meta": {'domain': 'LLMIntrinsic', 'domain_of': ['LLMIntrinsic']} })
    hasCapability: Optional[list[str]] = Field(default=None, description="""Indicates the technical capabilities this entry possesses.
""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'tech:hasCapability'} })
    implementsCapability: Optional[list[str]] = Field(default=None, description="""Indicates that this entity implements a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'LLMIntrinsic',
         'domain_of': ['Adapter', 'LLMIntrinsic'],
         'inverse': 'implementedByIntrinsic'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["LLMIntrinsic"] = Field(default="LLMIntrinsic", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

LLMQuestionPolicy

Bases: Policy

The policy guides how the language model should answer a diverse set of sensitive questions.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class LLMQuestionPolicy(Policy):
    """
    The policy guides how the language model should answer a diverse set of sensitive questions.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    hasRelatedRisk: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasReasonDenial: Optional[str] = Field(default=None, description="""Reason for denial""", json_schema_extra = { "linkml_meta": {'domain_of': ['LLMQuestionPolicy'], 'slot_uri': 'nexus:hasReasonDenial'} })
    hasShortReplyType: Optional[str] = Field(default=None, description="""Short reply type""", json_schema_extra = { "linkml_meta": {'domain_of': ['LLMQuestionPolicy'], 'slot_uri': 'nexus:hasShortReplyType'} })
    hasException: Optional[str] = Field(default=None, description="""Exception type""", json_schema_extra = { "linkml_meta": {'domain_of': ['LLMQuestionPolicy'], 'slot_uri': 'nexus:hasException'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isApplicableinLocality: Optional[list[str]] = Field(default=None, description="""A relationship where an entity has is applicable in these localities.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Control', 'Policy'], 'slot_uri': 'nexus:isApplicableinLocality'} })
    type: Literal["LLMQuestionPolicy"] = Field(default="LLMQuestionPolicy", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

LargeLanguageModel

Bases: AiModel

A large language model (LLM) is an AI model which supports a range of language-related tasks such as generation, summarization, classification, among others. A LLM is implemented as an artificial neural networks using a transformer architecture.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class LargeLanguageModel(AiModel):
    """
    A large language model (LLM) is an AI model which supports a range of language-related tasks such as generation, summarization, classification, among others. A LLM is implemented as an artificial neural networks using a transformer architecture.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'aliases': ['LLM'],
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system',
         'mixin': True,
         'slot_usage': {'isPartOf': {'description': 'Annotation that a Large Language '
                                                    'model is part of a family of '
                                                    'models',
                                     'name': 'isPartOf',
                                     'range': 'LargeLanguageModelFamily'}}})

    numParameters: Optional[int] = Field(default=None, description="""A property indicating the number of parameters in a LLM.""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    numTrainingTokens: Optional[int] = Field(default=None, description="""The number of tokens a AI model was trained on.""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    contextWindowSize: Optional[int] = Field(default=None, description="""The total length, in bytes, of an AI model's context window.""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    hasInputModality: Optional[list[str]] = Field(default=None, description="""A relationship indicating the input modalities supported by an AI component. Examples include text, image, video.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    hasOutputModality: Optional[list[str]] = Field(default=None, description="""A relationship indicating the output modalities supported by an AI component. Examples include text, image, video.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    hasTrainingData: Optional[list[str]] = Field(default=None, description="""A relationship indicating the datasets an AI model was trained on.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel'], 'slot_uri': 'airo:hasTrainingData'} })
    fine_tuning: Optional[str] = Field(default=None, description="""A description of the fine-tuning mechanism(s) applied to a model.""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    supported_languages: Optional[list[str]] = Field(default=None, description="""A list of languages, expressed as ISO two letter codes. For example, 'jp, fr, en, de'""", json_schema_extra = { "linkml_meta": {'domain_of': ['LargeLanguageModel']} })
    isPartOf: Optional[str] = Field(default=None, description="""Annotation that a Large Language model is part of a family of models""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    hasEvaluation: Optional[list[str]] = Field(default=None, description="""A relationship indicating that an entity has an AI evaluation result.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel', 'ThirdPartyEvaluationEngagement'],
         'slot_uri': 'dqv:hasQualityMeasurement'} })
    architecture: Optional[str] = Field(default=None, description="""A description of the architecture of an AI such as 'Decoder-only'.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    gpu_hours: Optional[int] = Field(default=None, description="""GPU consumption in terms of hours""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    power_consumption_w: Optional[int] = Field(default=None, description="""power consumption in Watts""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel']} })
    carbon_emitted: Optional[float] = Field(default=None, description="""The number of tons of carbon dioxide equivalent that are emitted during training""", ge=0, json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel'],
         'unit': {'descriptive_name': 'tons of CO2 equivalent', 'symbol': 't CO2-eq'}} })
    hasRiskControl: Optional[list[str]] = Field(default=None, description="""Indicates the control measures associated with a system or component to modify risks.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiModel'], 'slot_uri': 'airo:hasRiskControl'} })
    isProducedBy: Optional[str] = Field(default=None, description="""A relationship to the Organization instance which produces this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasModelCard: Optional[list[str]] = Field(default=None, description="""A relationship to model card references.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    performsTask: Optional[list[str]] = Field(default=None, description="""relationship indicating the AI tasks an AI model can perform.""", json_schema_extra = { "linkml_meta": {'domain_of': ['BaseAi']} })
    isProvidedBy: Optional[str] = Field(default=None, description="""Indicates provider of an AI system or component.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset', 'BaseAi'], 'slot_uri': 'airo:isProvidedBy'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

LargeLanguageModelFamily

Bases: Entity

A large language model family is a set of models that are provided by the same AI systems provider and are built around the same architecture, but differ e.g. in the number of parameters. Examples are Meta's Llama2 family or the IBM granite models.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class LargeLanguageModelFamily(Entity):
    """
    A large language model family is a set of models that are provided by the same AI systems provider and are built around the same architecture, but differ e.g. in the number of parameters. Examples are Meta's Llama2 family or the IBM granite models.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

License

Bases: Entity

The general notion of a license which defines terms and grants permissions to users of AI systems, datasets and software.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class License(Entity):
    """
    The general notion of a license which defines terms and grants permissions to users of AI systems, datasets and software.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:License',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    version: Optional[str] = Field(default=None, description="""The version of the entity embodied by a specified resource.""", json_schema_extra = { "linkml_meta": {'domain_of': ['License',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'AiTaskTaxonomy'],
         'slot_uri': 'schema:version'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

LifecycleStatus

Bases: str, Enum

Editorial / publication state of a catalogued entity. Permissible values align to the ADMS-status codelist where one exists; otherwise drawn from PSO vocabulary, and failing that, minted in this nexus namespace.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class LifecycleStatus(str, Enum):
    """
    Editorial / publication state of a catalogued entity. Permissible values align to the ADMS-status codelist where one exists; otherwise drawn from PSO vocabulary, and failing that, minted in this nexus namespace.
    """
    DRAFT = "DRAFT"
    """
    Initial draft under development.
    """
    REVIEW = "REVIEW"
    """
    Under editorial or technical review.
    """
    APPROVED = "APPROVED"
    """
    Approved / published as authoritative.
    """
    DEPRECATED = "DEPRECATED"
    """
    Discouraged for new use but still available.
    """
    SUPERSEDED = "SUPERSEDED"
    """
    Replaced by a newer version of this entity.
    """
    WITHDRAWN = "WITHDRAWN"
    """
    Removed / no longer available.
    """

APPROVED = 'APPROVED' class-attribute instance-attribute

Approved / published as authoritative.

DEPRECATED = 'DEPRECATED' class-attribute instance-attribute

Discouraged for new use but still available.

DRAFT = 'DRAFT' class-attribute instance-attribute

Initial draft under development.

REVIEW = 'REVIEW' class-attribute instance-attribute

Under editorial or technical review.

SUPERSEDED = 'SUPERSEDED' class-attribute instance-attribute

Replaced by a newer version of this entity.

WITHDRAWN = 'WITHDRAWN' class-attribute instance-attribute

Removed / no longer available.

LocalityOfUse

Bases: Entry

The area, e.g. facility or institution, in which an entity is used.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class LocalityOfUse(Entry):
    """
    The area, e.g. facility or institution, in which an entity is used.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:LocalityOfUse',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["LocalityOfUse"] = Field(default="LocalityOfUse", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

MetricConfig

Bases: Entity

Configuration for evaluation metrics

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class MetricConfig(Entity):
    """
    Configuration for evaluation metrics
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:metricconfig',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval'})

    lower_is_better: Optional[bool] = Field(default=None, description="""Whether lower scores are better""", json_schema_extra = { "linkml_meta": {'domain_of': ['MetricConfig']} })
    score_type: Optional[str] = Field(default=None, description="""Type of score (e.g., continuous)""", json_schema_extra = { "linkml_meta": {'domain_of': ['MetricConfig']} })
    min_score: Optional[float] = Field(default=None, description="""Minimum possible score""", json_schema_extra = { "linkml_meta": {'domain_of': ['MetricConfig']} })
    max_score: Optional[float] = Field(default=None, description="""Maximum possible score""", json_schema_extra = { "linkml_meta": {'domain_of': ['MetricConfig']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Modality

Bases: Entity

A modality supported by an Ai component. Examples include text, image, video.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Modality(Entity):
    """
    A modality supported by an Ai component. Examples include text, image, video.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:Modality',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

ModelInfo

Bases: Entity

Information about the AI model being evaluated

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class ModelInfo(Entity):
    """
    Information about the AI model being evaluated
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'nexus:modelinfo',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval'})

    model_name: Optional[str] = Field(default=None, description="""Name of the AI model""", json_schema_extra = { "linkml_meta": {'domain_of': ['ModelInfo']} })
    model_id: Optional[str] = Field(default=None, description="""Identifier of the AI model""", json_schema_extra = { "linkml_meta": {'domain_of': ['ModelInfo']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Obligation

Bases: Rule

A rule describing an obligation for performing an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Obligation(Rule):
    """
    A rule describing an obligation for performing an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'dpv:Obligation',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    type: Literal["Obligation"] = Field(default="Obligation", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Organization

Bases: Entity

Any organizational entity such as a corporation, educational institution, consortium, government, etc.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Organization(Entity):
    """
    Any organizational entity such as a corporation, educational institution, consortium, government, etc.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'schema:Organization',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    grants_license: Optional[str] = Field(default=None, description="""A relationship from a granting entity such as an Organization to a License instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Organization']} })
    type: Literal["Organization"] = Field(default="Organization", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Permission

Bases: Rule

A rule describing a permission to perform an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Permission(Rule):
    """
    A rule describing a permission to perform an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'dpv:Permission',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    type: Literal["Permission"] = Field(default="Permission", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Policy

Bases: Entity

A guidance document outlining any of: procedures, plans, principles, decisions, intent, or protocols.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Policy(Entity):
    """
    A guidance document outlining any of: procedures, plans, principles, decisions, intent, or protocols.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'dpv:Policy',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isApplicableinLocality: Optional[list[str]] = Field(default=None, description="""A relationship where an entity has is applicable in these localities.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Control', 'Policy'], 'slot_uri': 'nexus:isApplicableinLocality'} })
    type: Literal["Policy"] = Field(default="Policy", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Principle

Bases: Entry

A representation of values or norms that must be taken into consideration when conducting activities.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Principle(Entry):
    """
    A representation of values or norms that must be taken into consideration when conducting activities.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'dpv:Principle',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Principle"] = Field(default="Principle", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Prohibition

Bases: Rule

A rule describing a prohibition to perform an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Prohibition(Rule):
    """
    A rule describing a prohibition to perform an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'dpv:Prohibition',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    type: Literal["Prohibition"] = Field(default="Prohibition", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Purpose

Bases: Entry

The end goal for which an entity is used or an action is taken.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Purpose(Entry):
    """
    The end goal for which an entity is used or an action is taken.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:Purpose',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_system'})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where an entity is part of another entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Purpose"] = Field(default="Purpose", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Question

Bases: AiEval

An evaluation where a question has to be answered

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Question(AiEval):
    """
    An evaluation where a question has to be answered
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval'})

    text: str = Field(default=..., description="""The question itself""", json_schema_extra = { "linkml_meta": {'domain_of': ['Question']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasDataset: Optional[list[str]] = Field(default=None, description="""A relationship to datasets that are used.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval']} })
    hasTasks: Optional[list[str]] = Field(default=None, description="""The tasks or evaluations the benchmark is intended to assess.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval', 'EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasImplementation: Optional[list[str]] = Field(default=None, description="""A relationship to a implementation defining the risk evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval'], 'slot_uri': 'schema:url'} })
    hasUnitxtCard: Optional[list[str]] = Field(default=None, description="""A relationship to a Unitxt card defining the risk evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval'], 'slot_uri': 'schema:url'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'AiEval',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    bestValue: Optional[str] = Field(default=None, description="""Annotation of the best possible result of the evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval']} })
    hasBenchmarkMetadata: Optional[list[str]] = Field(default=None, description="""A relationship to a Benchmark Metadata Card which contains metadata about the benchmark.""", json_schema_extra = { "linkml_meta": {'domain': 'AiEval', 'domain_of': ['AiEval'], 'inverse': 'describesAiEval'} })
    isComposedOf: Optional[list[str]] = Field(default=None, description="""A relationship indicating that an AI evaluation maybe composed of other AI evaluations (e.g. it's an overall average of other scores).""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'AiEval']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Questionnaire

Bases: AiEval

A questionnaire groups questions

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Questionnaire(AiEval):
    """
    A questionnaire groups questions
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_eval',
         'slot_usage': {'isComposedOf': {'name': 'isComposedOf', 'range': 'Question'}}})

    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasDataset: Optional[list[str]] = Field(default=None, description="""A relationship to datasets that are used.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval']} })
    hasTasks: Optional[list[str]] = Field(default=None, description="""The tasks or evaluations the benchmark is intended to assess.""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval', 'EveryEvalAIResult', 'BenchmarkMetadataCard']} })
    hasImplementation: Optional[list[str]] = Field(default=None, description="""A relationship to a implementation defining the risk evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval'], 'slot_uri': 'schema:url'} })
    hasUnitxtCard: Optional[list[str]] = Field(default=None, description="""A relationship to a Unitxt card defining the risk evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval'], 'slot_uri': 'schema:url'} })
    hasLicense: Optional[str] = Field(default=None, description="""Indicates licenses associated with a resource""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Documentation',
                       'Vocabulary',
                       'Taxonomy',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'BaseAi',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'BenchmarkMetadataCard',
                       'Adapter'],
         'slot_uri': 'airo:hasLicense'} })
    hasRelatedRisk: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to a risk""", json_schema_extra = { "linkml_meta": {'domain': 'AiEval',
         'domain_of': ['Term',
                       'LLMQuestionPolicy',
                       'Action',
                       'AiSystem',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'Adapter',
                       'LLMIntrinsic']} })
    bestValue: Optional[str] = Field(default=None, description="""Annotation of the best possible result of the evaluation""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiEval']} })
    hasBenchmarkMetadata: Optional[list[str]] = Field(default=None, description="""A relationship to a Benchmark Metadata Card which contains metadata about the benchmark.""", json_schema_extra = { "linkml_meta": {'domain': 'AiEval', 'domain_of': ['AiEval'], 'inverse': 'describesAiEval'} })
    isComposedOf: Optional[list[str]] = Field(default=None, description="""A relationship indicating that an AI evaluation maybe composed of other AI evaluations (e.g. it's an overall average of other scores).""", json_schema_extra = { "linkml_meta": {'domain_of': ['AiSystem', 'AiEval']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Recommendation

Bases: Rule

A rule describing a recommendation for performing an activity

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Recommendation(Rule):
    """
    A rule describing a recommendation for performing an activity
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'abstract': True,
         'class_uri': 'dpv:Recommendation',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/common'})

    type: Literal["Recommendation"] = Field(default="Recommendation", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Requirement

Bases: Rule

A requirement representing a combination of obligation, permission, or prohibition for AI system assurance.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Requirement(Rule):
    """
    A requirement representing a combination of obligation, permission, or prohibition for AI system assurance.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_aiuc',
         'slot_usage': {'hasRule': {'description': 'Relationship indicating the '
                                                   'control activities (rules) of '
                                                   'which the requirement is composed.',
                                    'inlined': False,
                                    'name': 'hasRule'}}})

    hasApplication: Optional[list[AIUC1ApplicationCategory]] = Field(default=None, description="""The application category, Optional or Mandatory.""", json_schema_extra = { "linkml_meta": {'domain': 'Requirement',
         'domain_of': ['Requirement'],
         'slot_uri': 'nexus:hasApplication'} })
    hasFrequency: Optional[AIUC1Frequency] = Field(default=None, description="""The frequency""", json_schema_extra = { "linkml_meta": {'domain': 'Requirement',
         'domain_of': ['Requirement'],
         'slot_uri': 'nexus:hasFrequency'} })
    hasKeywords: Optional[list[str]] = Field(default=None, description="""A collection of keywords""", json_schema_extra = { "linkml_meta": {'domain': 'Requirement',
         'domain_of': ['Requirement'],
         'slot_uri': 'nexus:hasKeywords'} })
    hasPrinciple: Optional[list[str]] = Field(default=None, description="""The principle(s) this entry is composed of or belongs to""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['EvaluationStandard', 'Requirement'],
         'slot_uri': 'dpv:isPartOf'} })
    isApplicableToCapability: Optional[list[str]] = Field(default=None, description="""This evidence only applies to AI systems with this capability""", json_schema_extra = { "linkml_meta": {'domain': 'ControlActivity',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:isApplicableToCapability'} })
    hasRequirementType: Optional[AIUC1RequirementType] = Field(default=None, description="""The requirement type of whether this is preventive, detective, etc.""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['ControlActivity', 'Requirement'],
         'slot_uri': 'nexus:hasRequirementType'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Relationship indicating the control activities (rules) of which the requirement is composed.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Requirement"] = Field(default="Requirement", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

Risk

Bases: RiskConcept, Entry

The state of uncertainty associated with an AI system, that has the potential to cause harms

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class Risk(RiskConcept, Entry):
    """
    The state of uncertainty associated with an AI system, that has the potential to cause harms
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:Risk',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_risk',
         'mixins': ['RiskConcept'],
         'slot_usage': {'isPartOf': {'description': 'A relationship where a risk is '
                                                    'part of a risk group',
                                     'name': 'isPartOf',
                                     'range': 'RiskGroup'}}})

    hasRelatedAction: Optional[list[str]] = Field(default=None, description="""A relationship where an entity relates to an action""", json_schema_extra = { "linkml_meta": {'domain_of': ['Risk']} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isPartOf: Optional[str] = Field(default=None, description="""A relationship where a risk is part of a risk group""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry',
                       'Risk',
                       'CapabilityGroup',
                       'LargeLanguageModel',
                       'AiTaskGroup',
                       'Stakeholder'],
         'slot_uri': 'schema:isPartOf'} })
    detectsRiskConcept: Optional[list[str]] = Field(default=None, description="""The property airo:detectsRiskConcept indicates the control used for detecting risks, risk sources, consequences, and impacts.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskControl',
         'domain_of': ['Risk', 'RiskControl'],
         'exact_mappings': ['airo:detectsRiskConcept'],
         'inverse': 'isDetectedBy'} })
    tag: Optional[str] = Field(default=None, description="""A shost version of the name""", json_schema_extra = { "linkml_meta": {'domain_of': ['Risk']} })
    risk_type: Optional[str] = Field(default=None, description="""Annotation whether an AI risk occurs at input or output or is non-technical.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Risk']} })
    phase: Optional[str] = Field(default=None, description="""Annotation whether an AI risk shows specifically during the training-tuning or inference phase.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Risk']} })
    descriptor: Optional[list[str]] = Field(default=None, description="""Annotates whether an AI risk is a traditional risk, specific to or amplified by AI.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Risk']} })
    concern: Optional[str] = Field(default=None, description="""Some explanation about the concern related to an AI risk""", json_schema_extra = { "linkml_meta": {'domain_of': ['Risk']} })
    isDetectedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is detected by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'detectsRiskConcept'} })
    isMitigatedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is mitigated by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'mitigatesRiskConcept'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    isDefinedByVocabulary: Optional[str] = Field(default=None, description="""A relationship where a term or a term group is defined by a vocabulary""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'Term', 'Adapter', 'LLMIntrinsic'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    requiredByTask: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry is required to perform a specific AI task.""", json_schema_extra = { "linkml_meta": {'domain': 'Entry',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'requiresCapability'} })
    requiresCapability: Optional[list[Any]] = Field(default=None, description="""Indicates that this entry requires a specific capability""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'LargeLanguageModel', 'AiTask', 'Adapter'],
         'inverse': 'requiredByTask'} })
    implementedByAdapter: Optional[list[Any]] = Field(default=None, description="""Indicates that this capability is implemented by a specific adapter. This relationship distinguishes the abstract capability (what can be done) from the technical implementation mechanism (how it is added/extended via adapters).""", json_schema_extra = { "linkml_meta": {'domain': 'Any',
         'domain_of': ['Entry', 'Capability'],
         'inverse': 'implementsCapability'} })
    hasRule: Optional[list[str]] = Field(default=None, description="""Specifying applicability or inclusion of a rule within specified context.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entry', 'LLMQuestionPolicy', 'Rule', 'Requirement'],
         'slot_uri': 'dpv:hasRule'} })
    type: Literal["Risk"] = Field(default="Risk", description="""The entry type or class designation specifying what kind of entry this is.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

RiskConcept

Bases: Concept

An umbrella term for referring to risk, risk source, consequence and impact.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class RiskConcept(Concept):
    """
    An umbrella term for referring to risk, risk source, consequence and impact.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:RiskConcept',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_risk',
         'mixin': True})

    isDetectedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is detected by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'detectsRiskConcept'} })
    isMitigatedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is mitigated by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'mitigatesRiskConcept'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })
    type: Literal["RiskConcept"] = Field(default="RiskConcept", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })

RiskControl

Bases: RiskConcept, Control

A measure that maintains and/or modifies risk (and risk concepts)

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class RiskControl(RiskConcept, Control):
    """
    A measure that maintains and/or modifies risk (and risk concepts)
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'class_uri': 'airo:RiskControl',
         'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_risk',
         'mixin': True,
         'mixins': ['RiskConcept']})

    detectsRiskConcept: Optional[list[str]] = Field(default=None, description="""The property airo:detectsRiskConcept indicates the control used for detecting risks, risk sources, consequences, and impacts.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskControl',
         'domain_of': ['Risk', 'RiskControl'],
         'exact_mappings': ['airo:detectsRiskConcept'],
         'inverse': 'isDetectedBy'} })
    mitigatesRiskConcept: Optional[list[str]] = Field(default=None, description="""Indicates the control used for mitigating risks, risk sources, consequences, and impacts.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskControl',
         'domain_of': ['RiskControl'],
         'exact_mappings': ['airo:mitigatesRiskConcept'],
         'inverse': 'isMitigatedBy'} })
    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    isDetectedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is detected by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'detectsRiskConcept'} })
    isMitigatedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is mitigated by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'mitigatesRiskConcept'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    isApplicableinLocality: Optional[list[str]] = Field(default=None, description="""A relationship where an entity has is applicable in these localities.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Control', 'Policy'], 'slot_uri': 'nexus:isApplicableinLocality'} })
    hasExternalReference: Optional[list[str]] = Field(default=None, description="""External references / additional resources related to this entity, such as articles, tools, or datasets. Distinct from hasDocumentation, which documents the entity itself. External references are not necessarily curated or vetted, and quality will vary.""", json_schema_extra = { "linkml_meta": {'aliases': ['additional resources', 'external_links'],
         'close_mappings': ['rdfs:seeAlso'],
         'domain_of': ['Control', 'Entry'],
         'slot_uri': 'nexus:hasExternalReference'} })
    type: Literal["RiskControl"] = Field(default="RiskControl", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement']} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

RiskControlGroup

Bases: RiskConcept, Group

A group of AI system related risk controls.

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class RiskControlGroup(RiskConcept, Group):
    """
    A group of AI system related risk controls.
    """
    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({'from_schema': 'https://w3id.org/ai-atlas-nexus/ai_risk',
         'mixins': ['RiskConcept'],
         'slot_usage': {'hasPart': {'description': 'A relationship where a '
                                                   'riskcontrolgroup has a risk '
                                                   'control',
                                    'name': 'hasPart',
                                    'range': 'RiskControl'}}})

    isDefinedByTaxonomy: Optional[str] = Field(default=None, description="""A relationship where a concept or a concept group is defined by a taxonomy""", json_schema_extra = { "linkml_meta": {'domain_of': ['Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'RiskControlGroup',
                       'RiskGroup',
                       'Risk',
                       'RiskControl',
                       'Action',
                       'RiskIncident',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup',
                       'Stakeholder',
                       'StakeholderGroup',
                       'Requirement'],
         'slot_uri': 'schema:isPartOf'} })
    hasPart: Optional[list[str]] = Field(default=None, description="""A relationship where a riskcontrolgroup has a risk control""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group',
                       'RiskControlGroup',
                       'RiskGroup',
                       'CapabilityGroup',
                       'AiTaskDomain',
                       'AiTaskGroup'],
         'slot_uri': 'skos:member'} })
    isDetectedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is detected by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'detectsRiskConcept'} })
    isMitigatedBy: Optional[list[str]] = Field(default=None, description="""A relationship where a risk, risk source, consequence, or impact is mitigated by a risk control.""", json_schema_extra = { "linkml_meta": {'domain': 'RiskConcept',
         'domain_of': ['RiskConcept'],
         'inverse': 'mitigatesRiskConcept'} })
    isUsedWithinLocality: Optional[list[str]] = Field(default=None, description="""Specifies the domain an AI system is used within.""", json_schema_extra = { "linkml_meta": {'domain_of': ['RiskConcept', 'AiSystem'],
         'slot_uri': 'airo:isUsedWithinLocality'} })
    hasDocumentation: Optional[list[str]] = Field(default=None, description="""Indicates documentation associated with an entity.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Dataset',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Group',
                       'Entry',
                       'Term',
                       'Principle',
                       'Rule',
                       'RiskTaxonomy',
                       'RiskControlGroupTaxonomy',
                       'Action',
                       'BaseAi',
                       'LargeLanguageModelFamily',
                       'AiTaskTaxonomy',
                       'AiEval',
                       'EveryEvalAIResult',
                       'BenchmarkMetadataCard',
                       'ThirdPartyEvaluationEngagement',
                       'Adapter',
                       'LLMIntrinsic'],
         'slot_uri': 'airo:hasDocumentation'} })
    belongsToDomain: Optional[Any] = Field(default=None, description="""A relationship where a group belongs to a domain""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group', 'CapabilityGroup'], 'slot_uri': 'schema:isPartOf'} })
    type: Literal["RiskControlGroup"] = Field(default="RiskControlGroup", description="""The type or class designation of this entity instance.""", json_schema_extra = { "linkml_meta": {'designates_type': True,
         'domain_of': ['Organization',
                       'Vocabulary',
                       'Taxonomy',
                       'Concept',
                       'Control',
                       'Group',
                       'Entry',
                       'Policy',
                       'Rule',
                       'Permission',
                       'Prohibition',
                       'Obligation',
                       'Recommendation',
                       'Certification',
                       'EvaluationStandard',
                       'BenchmarkMetadataCard',
                       'ControlActivity',
                       'ControlActivityPermission',
                       'ControlActivityProhibition',
                       'ControlActivityObligation',
                       'ControlActivityRecommendation',
                       'Requirement'],
         'ifabsent': 'string(Group)'} })
    narrower: Optional[list[str]] = Field(default=None, description="""Related concepts that are narrower in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    broader: Optional[list[str]] = Field(default=None, description="""Related concepts that are broader in scope or hierarchy.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Group'], 'slot_uri': 'skos:narrower'} })
    id: str = Field(default=..., description="""A unique identifier to this instance of the model element. Example identifiers include UUID, URI, URN, etc.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:identifier'} })
    name: Optional[str] = Field(default=None, description="""A text name of this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity', 'BenchmarkMetadataCard'], 'slot_uri': 'schema:name'} })
    description: Optional[str] = Field(default=None, description="""The description of an entity""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:description'} })
    url: Optional[str] = Field(default=None, description="""An optional URL associated with this instance.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:url'} })
    dateCreated: Optional[date] = Field(default=None, description="""The date on which the entity was created.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateCreated'} })
    dateModified: Optional[date] = Field(default=None, description="""The date on which the entity was most recently modified.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'schema:dateModified'} })
    exact_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:exactMatch'} })
    close_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:closeMatch'} })
    related_mappings: Optional[list[Any]] = Field(default=None, description="""The property skos:relatedMatch is used to state an associative mapping link between two concepts.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:relatedMatch'} })
    narrow_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a narrower concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:narrowMatch'} })
    broad_mappings: Optional[list[Any]] = Field(default=None, description="""The property is used to state a hierarchical mapping link between two concepts, indicating that the concept linked to, is a broader concept than the originating concept.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'skos:broadMatch'} })
    isCategorizedAs: Optional[list[Any]] = Field(default=None, description="""A relationship where an entity has been deemed to be categorized""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'slot_uri': 'nexus:isCategorizedAs'} })
    hasLifecycleStatus: Optional[LifecycleStatus] = Field(default=None, description="""The editorial / publication lifecycle state of this entity. Distinct from AiLifecyclePhase, which describes an AI system's runtime evolution rather than the editorial workflow of a catalogued entry.""", json_schema_extra = { "linkml_meta": {'aliases': ['lifecycle_status', 'doc_status'],
         'domain_of': ['Entity'],
         'slot_uri': 'adms:status'} })
    notes: Optional[list[str]] = Field(default=None, description="""Free-text editorial notes, source breadcrumbs, or build-time provenance that do not belong in the user-facing description. Opaque to consumers.""", json_schema_extra = { "linkml_meta": {'domain_of': ['Entity'], 'recommended': False, 'slot_uri': 'skos:note'} })
    hasJurisdiction: Optional[list[Union[Jurisdiction, SubnationalJurisdiction, SupraNationalJurisdiction]]] = Field(default=None, description="""The legal or regulatory jurisdiction(s) applicable to an AI system, policy, risk, or obligation, expressed as an ISO 3166-1 alpha-2 country code (e.g. US), an ISO 3166-2 subdivision code (e.g. US-CA), a supra-national union (e.g. EU, EEA), or International. Values are listed in jurisdictions.yaml from the DPV Location vocabulary. Aligns with dpv:hasJurisdiction.""", json_schema_extra = { "linkml_meta": {'any_of': [{'range': 'Jurisdiction'},
                    {'range': 'SupraNationalJurisdiction'},
                    {'range': 'SubnationalJurisdiction'}],
         'domain_of': ['Documentation', 'Concept'],
         'see_also': ['https://w3id.org/dpv#hasJurisdiction'],
         'slot_uri': 'dpv:hasJurisdiction'} })

RiskControlGroupTaxonomy

Bases: Taxonomy

A taxonomy of AI system related risk controls groups

Source code in src/ai_atlas_nexus/ai_risk_ontology/datamodel/ai_risk_ontology.py

class RiskControlGroupTaxonomy(Taxonomy):
    """
    A taxonomy of AI system related risk controls groups
    """
    linkml_meta