@prefix : <https://ontology.inferal.com/modules/competency-question/> .
@prefix dcat: <http://www.w3.org/ns/dcat#> .
@prefix dcterms: <http://purl.org/dc/terms/> .
@prefix ex: <https://example.com/inferal/cqo-self-application/> .
@prefix mod: <https://w3id.org/mod#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

# Bootstrap seed
#
# This graph presupposes only RDF/Turtle, the stable CQ ontology namespace,
# the class/property IRIs needed to state the records, and the query artifact
# text. The ontology later describes those resources, but the fixture does not
# derive the vocabulary from itself and therefore is not a circular logical
# justification.

ex:inferal-editors
    a prov:Agent ;
    dcterms:title "Inferal ontology editors" .

<https://ontology.inferal.com/modules/competency-question/versions/0.1.0>
    a mod:SemanticArtefact ;
    dcterms:isVersionOf : ;
    dcterms:hasVersion "0.1.0" ;
    rdfs:label "Competency Question Ontology version 0.1.0" ;
    rdfs:comment "The versioned semantic artifact targeted by the checked-in self-application corpus." .

ex:self-application-use-case
    a :UseCase ;
    :useCaseText "An ontology maintainer evaluates whether the Competency Question Ontology still describes and tests its own competency-question contract after a change."@en .

ex:consumer-use-case
    a :UseCase ;
    :useCaseText "A tool discovers a competency question, explains why it exists, executes its formalization over a fixture, and reports the result without treating query or SHACL text as ontology axioms."@en .

ex:governance-use-case
    a :UseCase ;
    :useCaseText "A reviewer distinguishes accepted, in-review, and deprecated questions and traces each accepted question to requirements, stakeholders, and coverage claims."@en .

# Parameter roles are extensible fixture resources, not values governed by the
# CQ ontology. They classify logical inputs without asserting a direct
# mapping to an ontology term or SPARQL variable.
ex:resource-phrase-role
    rdfs:label "resource phrase role" ;
    rdfs:comment "A natural-language phrase that denotes a resource or resource kind." .

ex:relation-phrase-role
    rdfs:label "relation or evidence phrase role" ;
    rdfs:comment "A natural-language phrase that denotes a relation or supporting evidence." .

# templateText is the human-readable rendering. Elements carry occurrence
# identity; parameters carry the logical input identity shared by occurrences.
ex:which-template
    a :QuestionTemplate ;
    :templateText "Which [resources] are connected by [relation or evidence]?"@en ;
    :hasTemplateParameter
        ex:which-resources-parameter ,
        ex:which-relation-parameter ;
    :hasTemplateElement
        ex:which-element-0 ,
        ex:which-element-1 ,
        ex:which-element-2 ,
        ex:which-element-3 ,
        ex:which-element-4 ;
    dcterms:source <https://github.com/mkeet/CLaRO> .

ex:which-resources-parameter
    a :TemplateParameter ;
    :parameterName "resources" ;
    :parameterRole ex:resource-phrase-role .

ex:which-relation-parameter
    a :TemplateParameter ;
    :parameterName "relation-or-evidence" ;
    :parameterRole ex:relation-phrase-role .

ex:which-element-0
    a :TemplateTextSegment ;
    :elementIndex "0"^^xsd:nonNegativeInteger ;
    :segmentText "Which "@en .
ex:which-element-1
    a :TemplateSlot ;
    :elementIndex "1"^^xsd:nonNegativeInteger ;
    :usesParameter ex:which-resources-parameter .
ex:which-element-2
    a :TemplateTextSegment ;
    :elementIndex "2"^^xsd:nonNegativeInteger ;
    :segmentText " are connected by "@en .
ex:which-element-3
    a :TemplateSlot ;
    :elementIndex "3"^^xsd:nonNegativeInteger ;
    :usesParameter ex:which-relation-parameter .
ex:which-element-4
    a :TemplateTextSegment ;
    :elementIndex "4"^^xsd:nonNegativeInteger ;
    :segmentText "?"@en .

ex:how-template
    a :QuestionTemplate ;
    :templateText "How is [resource] represented or evaluated without [prohibited shortcut]?"@en ;
    :hasTemplateParameter
        ex:how-resource-parameter ,
        ex:how-shortcut-parameter ;
    :hasTemplateElement
        ex:how-element-0 ,
        ex:how-element-1 ,
        ex:how-element-2 ,
        ex:how-element-3 ,
        ex:how-element-4 ;
    dcterms:source <https://github.com/mkeet/CLaRO> .

ex:how-resource-parameter
    a :TemplateParameter ;
    :parameterName "resource" ;
    :parameterRole ex:resource-phrase-role .

ex:how-shortcut-parameter
    a :TemplateParameter ;
    :parameterName "prohibited-shortcut" .

ex:how-element-0
    a :TemplateTextSegment ;
    :elementIndex "0"^^xsd:nonNegativeInteger ;
    :segmentText "How is "@en .
ex:how-element-1
    a :TemplateSlot ;
    :elementIndex "1"^^xsd:nonNegativeInteger ;
    :usesParameter ex:how-resource-parameter .
ex:how-element-2
    a :TemplateTextSegment ;
    :elementIndex "2"^^xsd:nonNegativeInteger ;
    :segmentText " represented or evaluated without "@en .
ex:how-element-3
    a :TemplateSlot ;
    :elementIndex "3"^^xsd:nonNegativeInteger ;
    :usesParameter ex:how-shortcut-parameter .
ex:how-element-4
    a :TemplateTextSegment ;
    :elementIndex "4"^^xsd:nonNegativeInteger ;
    :segmentText "?"@en .

ex:does-template
    a :QuestionTemplate ;
    :templateText "Does [artifact] satisfy [testable condition]?"@en ;
    :hasTemplateParameter
        ex:does-artifact-parameter ,
        ex:does-condition-parameter ;
    :hasTemplateElement
        ex:does-element-0 ,
        ex:does-element-1 ,
        ex:does-element-2 ,
        ex:does-element-3 ,
        ex:does-element-4 ;
    dcterms:source <https://github.com/mkeet/CLaRO> .

# This fourth template demonstrates why slot resources are occurrences rather
# than parameters: the same logical input occurs at two distinct positions.
ex:repeated-slot-template
    a :QuestionTemplate ;
    :templateText "Does [artifact] describe [artifact] consistently?"@en ;
    :hasTemplateParameter ex:repeated-artifact-parameter ;
    :hasTemplateElement
        ex:repeated-element-0 ,
        ex:repeated-element-1 ,
        ex:repeated-element-2 ,
        ex:repeated-element-3 ,
        ex:repeated-element-4 ;
    dcterms:source <https://github.com/mkeet/CLaRO> .

ex:does-artifact-parameter
    a :TemplateParameter ;
    :parameterName "artifact" ;
    :parameterRole ex:resource-phrase-role .

ex:does-condition-parameter
    a :TemplateParameter ;
    :parameterName "testable-condition" .

ex:repeated-artifact-parameter
    a :TemplateParameter ;
    :parameterName "artifact" ;
    :parameterRole ex:resource-phrase-role .

ex:does-element-0
    a :TemplateTextSegment ;
    :elementIndex "0"^^xsd:nonNegativeInteger ;
    :segmentText "Does "@en .
ex:does-element-1
    a :TemplateSlot ;
    :elementIndex "1"^^xsd:nonNegativeInteger ;
    :usesParameter ex:does-artifact-parameter .
ex:does-element-2
    a :TemplateTextSegment ;
    :elementIndex "2"^^xsd:nonNegativeInteger ;
    :segmentText " satisfy "@en .
ex:does-element-3
    a :TemplateSlot ;
    :elementIndex "3"^^xsd:nonNegativeInteger ;
    :usesParameter ex:does-condition-parameter .
ex:does-element-4
    a :TemplateTextSegment ;
    :elementIndex "4"^^xsd:nonNegativeInteger ;
    :segmentText "?"@en .

ex:repeated-element-0
    a :TemplateTextSegment ;
    :elementIndex "0"^^xsd:nonNegativeInteger ;
    :segmentText "Does "@en .
ex:repeated-element-1
    a :TemplateSlot ;
    :elementIndex "1"^^xsd:nonNegativeInteger ;
    :usesParameter ex:repeated-artifact-parameter .
ex:repeated-element-2
    a :TemplateTextSegment ;
    :elementIndex "2"^^xsd:nonNegativeInteger ;
    :segmentText " describe "@en .
ex:repeated-element-3
    a :TemplateSlot ;
    :elementIndex "3"^^xsd:nonNegativeInteger ;
    :usesParameter ex:repeated-artifact-parameter .
ex:repeated-element-4
    a :TemplateTextSegment ;
    :elementIndex "4"^^xsd:nonNegativeInteger ;
    :segmentText " consistently?"@en .

# Qualified instantiations bind logical parameters, not slot occurrences. The
# ordered realization query can therefore reuse one binding at repeated slots.
ex:does-contract-instantiation
    a :TemplateInstantiation ;
    :usesTemplate ex:does-template ;
    :realizesFormulation ex:formulation-template-instantiation ;
    :hasTemplateBinding
        ex:does-contract-artifact-binding ,
        ex:does-contract-condition-binding ;
    prov:wasAttributedTo ex:inferal-editors .

ex:does-contract-artifact-binding
    a :TemplateBinding ;
    :bindsParameter ex:does-artifact-parameter ;
    :boundResource :TemplateInstantiation ;
    :bindingText "the template realization contract"@en .

ex:does-contract-condition-binding
    a :TemplateBinding ;
    :bindsParameter ex:does-condition-parameter ;
    :boundLiteral "exact ordered reconstruction"@en ;
    :bindingText "exact ordered reconstruction"@en .

ex:repeated-recursion-instantiation
    a :TemplateInstantiation ;
    :usesTemplate ex:repeated-slot-template ;
    :realizesFormulation ex:formulation-recursion-template-realization ;
    :hasTemplateBinding ex:repeated-recursion-artifact-binding ;
    prov:wasAttributedTo ex:inferal-editors .

ex:repeated-recursion-artifact-binding
    a :TemplateBinding ;
    :bindsParameter ex:repeated-artifact-parameter ;
    :boundResource : ;
    :bindingText "the Competency Question Ontology"@en .

# Requirements

ex:requirement-first-class
    a :OntologyRequirement ;
    :requirementText "Competency questions must have stable resource identity independent of their formulations."@en .

ex:requirement-traceability
    a :OntologyRequirement ;
    :requirementText "Each accepted question must trace to a requirement, use case, and stakeholder."@en .

ex:requirement-target
    a :OntologyRequirement ;
    :requirementText "A question must identify its target semantic artifact and, when evaluated against a release, its target version."@en .

ex:requirement-expectation
    a :OntologyRequirement ;
    :requirementText "Questions must distinguish expected answers and answer constraints from observed execution results."@en .

ex:requirement-execution
    a :OntologyRequirement ;
    :requirementText "Executable formalizations must identify query language, query text, fixture, concrete execution, result, and status."@en .

ex:requirement-governance
    a :OntologyRequirement ;
    :requirementText "Question lifecycle and review state must be independently representable."@en .

ex:requirement-patterns
    a :OntologyRequirement ;
    :requirementText "Question kinds and reusable natural-language templates must remain distinct from executable formal queries."@en .

ex:requirement-template-elements
    a :OntologyRequirement ;
    :requirementText "A template must expose ordered fixed-text and slot occurrences without requiring consumers to parse its human-readable rendering."@en .

ex:requirement-template-instantiation
    a :OntologyRequirement ;
    :requirementText "A qualified template instantiation must connect one question, template, and formulation, bind each resource-identified parameter once, and expose deterministic ordered rendering fragments."@en .

ex:requirement-recursion
    a :OntologyRequirement ;
    :requirementText "The ontology's own question corpus must executable-test the recursive contract and public-term coverage."@en .

ex:requirement-bootstrap
    a :OntologyRequirement ;
    :requirementText "Self-description must disclose the minimal seed representation and must not be presented as circular logical justification."@en .

ex:requirement-satisfaction
    a :OntologyRequirement ;
    :requirementText "Machine-checkable answer constraints must be compared with observed execution results through qualified expectation assessments."@en .

ex:requirement-current-evidence
    a :OntologyRequirement ;
    :requirementText "A passing execution must identify the target semantic-artifact version it actually used so stale evidence can be detected."@en .

ex:requirement-coformalization
    a :OntologyRequirement ;
    :requirementText "The self-application contract must demonstrate multiple executable formalizations for one competency question and detect disagreement on a shared semantic fixture."@en .

# Natural-language formulations

ex:formulation-first-class
    a :QuestionFormulation ;
    :formulationText "Which first-class competency questions define the Competency Question Ontology, and what natural-language formulations express them?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-traceability
    a :QuestionFormulation ;
    :formulationText "Which ontology requirement, use case, and stakeholder motivate each self-defining competency question?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-target
    a :QuestionFormulation ;
    :formulationText "Which ontology module and version does each self-defining competency question target?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-expectation
    a :QuestionFormulation ;
    :formulationText "Which expected answer or answer constraint is connected to each self-defining competency question?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-execution
    a :QuestionFormulation ;
    :formulationText "Which formal query, fixture, execution, result, and status provide executable evidence for the self-application corpus?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-governance
    a :QuestionFormulation ;
    :formulationText "What lifecycle and review states apply to each self-defining competency question?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-patterns
    a :QuestionFormulation ;
    :formulationText "Which CQ kinds classify the self-defining questions, and which reusable natural-language templates remain independent of their formal queries?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-template-elements
    a :QuestionFormulation ;
    :formulationText "Which ordered fixed-text and slot occurrences constitute each self-application template, including repeated uses of one logical parameter?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-template-instantiation
    a :QuestionFormulation ;
    :formulationText "Does the template realization contract satisfy exact ordered reconstruction?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-recursion
    a :QuestionFormulation ;
    :formulationText "Which declared public classes and properties lack qualified coverage, and which seeded mutations escape detection by the recursive acceptance contract?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

# This deliberate paraphrase is exactly realized by the repeated-slot template.
# Both slot occurrences use one parameter and therefore require one binding.
ex:formulation-recursion-template-realization
    a :QuestionFormulation ;
    :formulationText "Does the Competency Question Ontology describe the Competency Question Ontology consistently?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-bootstrap
    a :QuestionFormulation ;
    :formulationText "Which resources constitute the minimal seed representation that exists before the ontology describes and executes tests over its own competency questions?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-satisfaction
    a :QuestionFormulation ;
    :formulationText "Which machine-checkable answer constraints are satisfied by observed execution results, and how is an executed empty result distinguished from an unknown or not-run result?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-current-evidence
    a :QuestionFormulation ;
    :formulationText "Which passing executions used a target ontology version different from the version currently targeted by their evaluated competency questions?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

ex:formulation-coformalization
    a :QuestionFormulation ;
    :formulationText "Where one competency question has multiple formal queries, do their executions agree with the declared expected outcome over the shared semantic fixture?"@en ;
    prov:wasAttributedTo ex:inferal-editors .

# Expected answers

ex:answer-first-class
    a :ExpectedAnswer ;
    :answerText "Fourteen stable competency-question resources are members of the self-application corpus, each with an independent formulation resource."@en .

ex:answer-traceability
    a :ExpectedAnswer ;
    :answerText "Every self-defining question links to at least one requirement, use case, and stakeholder agent."@en .

ex:answer-target
    a :ExpectedAnswer ;
    :answerText "Every self-defining question targets the module IRI and its 0.1.0 version IRI, which identifies the module with dcterms:isVersionOf."@en .

ex:answer-expectation
    a :ExpectedAnswer ;
    :answerText "Every self-defining question has a reviewable ExpectedAnswer resource distinct from its execution result."@en .

ex:answer-execution
    a :ExpectedAnswer ;
    :answerText "The SPARQL 1.1 acceptance query executes over this fixture plus the ontology and returns zero regression rows."@en .

ex:answer-governance
    a :ExpectedAnswer ;
    :answerText "Every self-defining question is accepted, approved, and independently marked for design and regression use."@en .

ex:answer-patterns
    a :ExpectedAnswer ;
    :answerText "Two scope-setting questions have the QuO/ROCQS scoping kind and twelve answerable self-checks have the validation kind. No resource-link lookup is mislabeled as a relationship kind, and bootstrap is not mislabeled as foundational. Four CLaRO-informed templates remain independent resources."@en .

ex:answer-template-elements
    a :ExpectedAnswer ;
    :answerText "Four templates expose twenty ordered element occurrences and seven resource-identified parameters. Two occurrences in the repeated-slot template use the same artifact parameter."@en .

ex:answer-template-instantiation
    a :ExpectedAnswer ;
    :answerText "Two qualified instantiations each return five ordered fragments that reconstruct their linked formulation exactly; the repeated template uses one binding at two slot positions."@en .

ex:answer-recursion
    a :ExpectedAnswer ;
    :answerText "Every public class and property has a CoveredStatus assertion, and removing required recursive links or coverage makes the acceptance query return a regression."@en .

ex:answer-bootstrap
    a :ExpectedAnswer ;
    :answerText "The seed is RDF/Turtle plus stable vocabulary IRIs, explicit instances, and executable query text. The ontology describes that seed after it exists; it does not derive or logically justify its own vocabulary."@en .

ex:constraint-zero-regressions
    a :AnswerConstraint ;
    :constraintExpression "0" ;
    :constraintLanguage :ResultCardinalityConstraintLanguage .

ex:answer-current-evidence
    a :ExpectedAnswer ;
    :answerText "Every passing self-application execution records the 0.1.0 target version with prov:used; changing a question target without a matching execution produces a stale-evidence regression."@en .

ex:answer-coformalization
    a :ExpectedAnswer ;
    :answerText "The row-producing and boolean SPARQL formalizations both pass the complete fixture, and both expose the seeded public-term coverage mutation."@en .

# Self-defining competency questions
#
# Kind follows QuO/ROCQS function, not surface wording. The first-class and
# bootstrap questions demarcate the module boundary and are Scoping CQs. The
# remaining questions are answerable checks on module content and therefore
# Validation CQs. Retrieving RDF links does not make a question an RCQ, and
# "foundational" is reserved for foundational-ontology alignment/interrogation.

ex:cq-first-class
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-first-class ;
    :addressesRequirement ex:requirement-first-class ;
    :supportsUseCase ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ScopingQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-first-class ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-traceability
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-traceability ;
    :addressesRequirement ex:requirement-traceability ;
    :supportsUseCase ex:governance-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-traceability ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-target
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-target ;
    :addressesRequirement ex:requirement-target ;
    :supportsUseCase ex:consumer-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-target ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-expectation
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-expectation ;
    :addressesRequirement ex:requirement-expectation ;
    :supportsUseCase ex:consumer-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-expectation ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-execution
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-execution ;
    :addressesRequirement ex:requirement-execution ;
    :supportsUseCase ex:consumer-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-execution ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-governance
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-governance ;
    :addressesRequirement ex:requirement-governance ;
    :supportsUseCase ex:governance-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-governance ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-patterns
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-patterns ;
    :addressesRequirement ex:requirement-patterns ;
    :supportsUseCase ex:consumer-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-patterns ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-template-elements
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-template-elements ;
    :addressesRequirement ex:requirement-template-elements ;
    :supportsUseCase ex:consumer-use-case, ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-template-elements ;
    :hasFormalQuery ex:template-element-extraction-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-template-instantiation
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-template-instantiation ;
    :addressesRequirement ex:requirement-template-instantiation ;
    :supportsUseCase ex:consumer-use-case, ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :DesignPurpose, :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-template-instantiation ;
    :hasFormalQuery ex:template-realization-query ;
    :hasTemplateInstantiation ex:does-contract-instantiation ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-recursion
    a :CompetencyQuestion ;
    :hasFormulation
        ex:formulation-recursion ,
        ex:formulation-recursion-template-realization ;
    :addressesRequirement ex:requirement-recursion ;
    :supportsUseCase ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-recursion ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :hasTemplateInstantiation ex:repeated-recursion-instantiation ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-bootstrap
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-bootstrap ;
    :addressesRequirement ex:requirement-bootstrap ;
    :supportsUseCase ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ScopingQuestion ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-bootstrap ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-satisfaction
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-satisfaction ;
    :addressesRequirement ex:requirement-satisfaction ;
    :supportsUseCase ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:constraint-zero-regressions ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-current-evidence
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-current-evidence ;
    :addressesRequirement ex:requirement-current-evidence ;
    :supportsUseCase ex:governance-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-current-evidence ;
    :hasFormalQuery ex:self-application-acceptance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:cq-coformalization
    a :CompetencyQuestion ;
    :hasFormulation ex:formulation-coformalization ;
    :addressesRequirement ex:requirement-coformalization ;
    :supportsUseCase ex:self-application-use-case ;
    :hasStakeholder ex:inferal-editors ;
    :questionKind :ValidationQuestion ;
    :questionPurpose :EvaluationPurpose, :RegressionPurpose ;
    :targetsArtifact : ;
    :targetsVersion <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    :hasAnswerExpectation ex:answer-coformalization ;
    :hasFormalQuery
        ex:self-application-acceptance-query ,
        ex:self-application-conformance-query ;
    :lifecycleState :AcceptedState ;
    :reviewState :ApprovedState .

ex:self-application-corpus
    a :QuestionSet ;
    :containsQuestion
        ex:cq-bootstrap ,
        ex:cq-coformalization ,
        ex:cq-current-evidence ,
        ex:cq-execution ,
        ex:cq-expectation ,
        ex:cq-first-class ,
        ex:cq-governance ,
        ex:cq-patterns ,
        ex:cq-recursion ,
        ex:cq-satisfaction ,
        ex:cq-target ,
        ex:cq-template-elements ,
        ex:cq-template-instantiation ,
        ex:cq-traceability ;
    :questionPurpose :DesignPurpose, :RegressionPurpose ;
    :hasStakeholder ex:inferal-editors ;
    dcterms:title "Competency Question Ontology self-application corpus" .

# The formal query and fixture are resources distinct from their source text.

ex:self-application-fixture
    a :TestFixture ;
    dcterms:format "text/turtle" ;
    dcat:downloadURL <https://ontology.inferal.com/modules/competency-question/queries/self-application-acceptance.example.ttl> .

ex:template-element-extraction-query
    a :FormalQuery ;
    :queryLanguage <https://www.w3.org/TR/sparql11-query/> ;
    :queryText """PREFIX : <https://ontology.inferal.com/modules/competency-question/>

SELECT ?template ?element ?index ?elementKind ?value ?parameter ?parameterRole WHERE {
  ?template a :QuestionTemplate ;
            :hasTemplateElement ?element .
  ?element :elementIndex ?index .
  {
    ?element a :TemplateTextSegment ;
             :segmentText ?value .
    BIND(:TemplateTextSegment AS ?elementKind)
  }
  UNION
  {
    ?element a :TemplateSlot ;
             :usesParameter ?parameter .
    ?parameter :parameterName ?value .
    BIND(:TemplateSlot AS ?elementKind)
    OPTIONAL { ?parameter :parameterRole ?parameterRole . }
  }
}
ORDER BY ?template ?index""" ;
    :usesFixture ex:self-application-fixture ;
    dcterms:title "Ordered template-element extraction query" ;
    dcat:downloadURL <https://ontology.inferal.com/modules/competency-question/queries/extract-template-elements.rq> .

ex:template-realization-query
    a :FormalQuery ;
    :queryLanguage <https://www.w3.org/TR/sparql11-query/> ;
    :queryText """PREFIX : <https://ontology.inferal.com/modules/competency-question/>

SELECT ?instantiation ?formulation ?index ?elementKind ?fragment
       ?parameter ?boundResource ?boundLiteral WHERE {
  ?instantiation a :TemplateInstantiation ;
                 :usesTemplate ?template ;
                 :realizesFormulation ?formulation .
  ?template :hasTemplateElement ?element .
  ?element :elementIndex ?index .
  {
    ?element a :TemplateTextSegment ;
             :segmentText ?fragment .
    BIND(:TemplateTextSegment AS ?elementKind)
  }
  UNION
  {
    ?element a :TemplateSlot ;
             :usesParameter ?parameter .
    ?instantiation :hasTemplateBinding ?binding .
    ?binding :bindsParameter ?parameter ;
             :bindingText ?fragment .
    OPTIONAL { ?binding :boundResource ?boundResource . }
    OPTIONAL { ?binding :boundLiteral ?boundLiteral . }
    BIND(:TemplateSlot AS ?elementKind)
  }
}
ORDER BY ?instantiation ?index""" ;
    :usesFixture ex:self-application-fixture ;
    dcterms:title "Qualified template-realization query" ;
    dcat:downloadURL <https://ontology.inferal.com/modules/competency-question/queries/realize-template.rq> .

ex:self-application-acceptance-query
    a :FormalQuery ;
    :queryLanguage <https://www.w3.org/TR/sparql11-query/> ;
    :queryText """PREFIX : <https://ontology.inferal.com/modules/competency-question/>
PREFIX ex: <https://example.com/inferal/cqo-self-application/>
PREFIX dcat: <http://www.w3.org/ns/dcat#>
PREFIX dcterms: <http://purl.org/dc/terms/>
PREFIX mod: <https://w3id.org/mod#>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>

SELECT DISTINCT ?check ?subject ?detail WHERE {
  {
    ?subject a :CompetencyQuestion .
    VALUES (?predicate ?check) {
      (:hasFormulation "missing formulation")
      (:addressesRequirement "missing requirement")
      (:supportsUseCase "missing use case")
      (:hasStakeholder "missing stakeholder")
      (:questionKind "missing question kind")
      (:questionPurpose "missing question purpose")
      (:targetsArtifact "missing target artifact")
      (:targetsVersion "missing target version")
      (:hasAnswerExpectation "missing answer expectation")
      (:hasFormalQuery "missing formal query")
      (:lifecycleState "missing lifecycle state")
      (:reviewState "missing review state")
    }
    FILTER NOT EXISTS { ?subject ?predicate ?value . }
    BIND(STR(?predicate) AS ?detail)
  }
  UNION
  {
    VALUES (?subject ?expectedKind) {
      (ex:cq-first-class :ScopingQuestion)
      (ex:cq-traceability :ValidationQuestion)
      (ex:cq-target :ValidationQuestion)
      (ex:cq-expectation :ValidationQuestion)
      (ex:cq-execution :ValidationQuestion)
      (ex:cq-governance :ValidationQuestion)
      (ex:cq-patterns :ValidationQuestion)
      (ex:cq-template-elements :ValidationQuestion)
      (ex:cq-template-instantiation :ValidationQuestion)
      (ex:cq-recursion :ValidationQuestion)
      (ex:cq-bootstrap :ScopingQuestion)
      (ex:cq-satisfaction :ValidationQuestion)
      (ex:cq-current-evidence :ValidationQuestion)
      (ex:cq-coformalization :ValidationQuestion)
    }
    FILTER NOT EXISTS { ?subject :questionKind ?expectedKind . }
    BIND("unexpected self-application question kind" AS ?check)
    BIND(STR(?expectedKind) AS ?detail)
  }
  UNION
  {
    ?subject a :CompetencyQuestion ;
             :targetsArtifact ?artifact ;
             :targetsVersion ?version .
    FILTER NOT EXISTS { ?version dcterms:isVersionOf ?artifact . }
    BIND("version does not identify target artifact" AS ?check)
    BIND(STR(?version) AS ?detail)
  }
  UNION
  {
    ?subject a :CompetencyQuestion ;
             :hasFormalQuery ?query .
    FILTER NOT EXISTS {
      ?query a :FormalQuery ;
             :queryText ?queryText ;
             :queryLanguage ?queryLanguage ;
             :usesFixture ?fixture ;
             dcat:downloadURL ?queryLocation .
      ?fixture a :TestFixture ;
               dcat:downloadURL ?fixtureLocation .
    }
    BIND("incomplete formal query artifact" AS ?check)
    BIND(STR(?query) AS ?detail)
  }
  UNION
  {
    ?subject a :CompetencyQuestion ;
             :hasFormalQuery ?query .
    FILTER NOT EXISTS {
      ?execution a :QueryExecution ;
                 :executionOf ?query ;
                 :evaluatesQuestion ?subject ;
                 :usesFixture ?fixture ;
                 :hasExecutionResult ?result .
      ?query :usesFixture ?fixture .
      ?result a :ExecutionResult ;
              :executionStatus :PassedStatus ;
              prov:wasGeneratedBy ?execution .
    }
    BIND("missing passed execution evidence" AS ?check)
    BIND(STR(?query) AS ?detail)
  }
  UNION
  {
    ?execution a :QueryExecution ;
               :evaluatesQuestion ?subject ;
               :hasExecutionResult ?result .
    ?subject :targetsVersion ?version .
    ?result :executionStatus :PassedStatus .
    FILTER NOT EXISTS { ?execution prov:used ?version . }
    BIND("passed execution did not use current target version" AS ?check)
    BIND(STR(?version) AS ?detail)
  }
  UNION
  {
    ?subject a :ExecutionResult ;
             :executionStatus ?status .
    VALUES ?status { :PassedStatus :FailedStatus }
    FILTER NOT EXISTS {
      ?subject (:resultCardinality|:resultBoolean) ?observation .
    }
    BIND("completed result lacks machine observation" AS ?check)
    BIND(STR(?status) AS ?detail)
  }
  UNION
  {
    ?subject a :ExecutionResult ;
             :executionStatus ?status ;
             (:resultCardinality|:resultBoolean) ?observation .
    VALUES ?status { :NotRunStatus :ErrorStatus }
    BIND("non-completed result claims machine observation" AS ?check)
    BIND(STR(?observation) AS ?detail)
  }
  UNION
  {
    ?execution a :QueryExecution ;
               :evaluatesQuestion ?subject ;
               :hasExecutionResult ?result .
    ?subject :hasAnswerExpectation ?expectation .
    ?expectation a :AnswerConstraint .
    FILTER NOT EXISTS {
      ?assessment a :ExpectationAssessment ;
                  :assessesResult ?result ;
                  :assessesExpectation ?expectation ;
                  :expectationSatisfied true .
    }
    BIND("machine-checkable expectation lacks satisfied assessment" AS ?check)
    BIND(STR(?expectation) AS ?detail)
  }
  UNION
  {
    ?subject a :ExpectationAssessment ;
             :assessesResult ?result ;
             :assessesExpectation ?expectation ;
             :expectationSatisfied ?stated .
    ?result :resultCardinality ?observed .
    ?expectation :constraintLanguage :ResultCardinalityConstraintLanguage ;
                 :constraintExpression ?expression .
    BIND(xsd:integer(?expression) AS ?expected)
    BIND(?observed = ?expected AS ?computed)
    FILTER(?stated != ?computed)
    BIND("expectation assessment disagrees with result cardinality" AS ?check)
    BIND(CONCAT(STR(?observed), " observed; ", STR(?expected), " expected") AS ?detail)
  }
  UNION
  {
    ?subject a :QuestionTemplate .
    FILTER NOT EXISTS {
      ?subject :templateText ?templateText ;
               :hasTemplateElement ?element .
    }
    BIND("template lacks extractable element structure" AS ?check)
    BIND(STR(?subject) AS ?detail)
  }
  UNION
  {
    ?subject a ?templateElementKind .
    VALUES ?templateElementKind {
      :TemplateElement
      :TemplateTextSegment
      :TemplateSlot
    }
    FILTER NOT EXISTS {
      ?template :hasTemplateElement ?subject .
      ?subject :elementIndex ?index .
      {
        ?subject a :TemplateTextSegment ;
                 :segmentText ?value .
      }
      UNION
      {
        ?subject a :TemplateSlot ;
                 :usesParameter ?value .
      }
    }
    BIND("incomplete template element" AS ?check)
    BIND(STR(?subject) AS ?detail)
  }
  UNION
  {
    ?subject a :QuestionTemplate .
    {
      ?subject :hasTemplateElement ?left, ?right .
      ?left :elementIndex ?index .
      ?right :elementIndex ?index .
      FILTER(?left != ?right)
      BIND(CONCAT("duplicate index ", STR(?index)) AS ?detail)
    }
    UNION
    {
      ?subject :hasTemplateElement ?element .
      ?element :elementIndex ?index .
      FILTER(?index > 0)
      FILTER NOT EXISTS {
        ?subject :hasTemplateElement ?previous .
        ?previous :elementIndex ?previousIndex .
        FILTER(?previousIndex = ?index - 1)
      }
      BIND(CONCAT("missing index before ", STR(?index)) AS ?detail)
    }
    BIND("template element sequence is not contiguous" AS ?check)
  }
  UNION
  {
    ?subject a :TemplateParameter .
    FILTER NOT EXISTS {
      ?template :hasTemplateParameter ?subject ;
                :hasTemplateElement ?slot .
      ?subject :parameterName ?parameterName .
      ?slot a :TemplateSlot ;
            :usesParameter ?subject .
    }
    BIND("incomplete or unused template parameter" AS ?check)
    BIND(STR(?subject) AS ?detail)
  }
  UNION
  {
    ?subject a :TemplateSlot ;
             :usesParameter ?parameter .
    ?template :hasTemplateElement ?subject .
    FILTER NOT EXISTS { ?template :hasTemplateParameter ?parameter . }
    BIND("slot uses parameter from another template" AS ?check)
    BIND(STR(?parameter) AS ?detail)
  }
  UNION
  {
    ?subject a :QuestionTemplate ;
             :hasTemplateParameter ?left, ?right .
    ?left :parameterName ?parameterName .
    ?right :parameterName ?parameterName .
    FILTER(?left != ?right)
    BIND("template parameter names are not unique" AS ?check)
    BIND(STR(?parameterName) AS ?detail)
  }
  UNION
  {
    ?subject a :TemplateInstantiation .
    FILTER NOT EXISTS {
      ?question :hasTemplateInstantiation ?subject ;
                :hasFormulation ?formulation .
      ?subject :usesTemplate ?template ;
               :realizesFormulation ?formulation .
    }
    BIND("incomplete template instantiation" AS ?check)
    BIND(STR(?subject) AS ?detail)
  }
  UNION
  {
    ?subject a :TemplateInstantiation ;
             :usesTemplate ?template .
    {
      ?template :hasTemplateParameter ?parameter .
      FILTER NOT EXISTS {
        ?subject :hasTemplateBinding ?binding .
        ?binding :bindsParameter ?parameter .
      }
      BIND("missing parameter binding" AS ?check)
    }
    UNION
    {
      ?subject :hasTemplateBinding ?binding .
      ?binding :bindsParameter ?parameter .
      FILTER NOT EXISTS { ?template :hasTemplateParameter ?parameter . }
      BIND("binding targets undeclared parameter" AS ?check)
    }
    UNION
    {
      ?subject :hasTemplateBinding ?left, ?right .
      ?left :bindsParameter ?parameter .
      ?right :bindsParameter ?parameter .
      FILTER(?left != ?right)
      BIND("parameter has duplicate bindings" AS ?check)
    }
    BIND(STR(?parameter) AS ?detail)
  }
  UNION
  {
    ?subject a :TemplateBinding .
    {
      FILTER NOT EXISTS { ?instantiation :hasTemplateBinding ?subject . }
    }
    UNION
    {
      FILTER NOT EXISTS { ?subject :bindsParameter ?parameter . }
    }
    UNION
    {
      FILTER NOT EXISTS { ?subject :bindingText ?bindingText . }
    }
    UNION
    {
      FILTER NOT EXISTS {
        ?subject (:boundResource|:boundLiteral) ?boundValue .
      }
    }
    UNION
    {
      ?subject :boundResource ?boundResource ;
               :boundLiteral ?boundLiteral .
    }
    BIND("incomplete or ambiguous template binding" AS ?check)
    BIND(STR(?subject) AS ?detail)
  }
  UNION
  {
    ?subject a :QuestionSet ;
             :containsQuestion ?question .
    FILTER NOT EXISTS {
      ?question a :CompetencyQuestion ;
                :questionPurpose :RegressionPurpose .
    }
    BIND("corpus member is not a regression question" AS ?check)
    BIND(STR(?question) AS ?detail)
  }
  UNION
  {
    ?subject ?termKind ?kind .
    VALUES ?termKind { rdf:type }
    VALUES ?kind { rdfs:Class rdf:Property }
    FILTER(STRSTARTS(STR(?subject), STR(:)))
    FILTER(?subject != :)
    FILTER NOT EXISTS {
      ?coverage a :CoverageAssertion ;
                :coveredResource ?subject ;
                :coverageStatus :CoveredStatus .
    }
    BIND("public term lacks covered assertion" AS ?check)
    BIND(STR(?kind) AS ?detail)
  }
}
ORDER BY ?check ?subject""" ;
    :usesFixture ex:self-application-fixture ;
    dcterms:title "Self-application recursive acceptance query" ;
    dcat:downloadURL <https://ontology.inferal.com/modules/competency-question/queries/self-application-acceptance.rq> .

ex:self-application-conformance-query
    a :FormalQuery ;
    :queryLanguage <https://www.w3.org/TR/sparql11-query/> ;
    :queryText """PREFIX : <https://ontology.inferal.com/modules/competency-question/>
PREFIX ex: <https://example.com/inferal/cqo-self-application/>
PREFIX prov: <http://www.w3.org/ns/prov#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>

ASK WHERE {
  FILTER NOT EXISTS {
    ?question a :CompetencyQuestion .
    VALUES ?predicate {
      :hasFormulation
      :addressesRequirement
      :supportsUseCase
      :hasStakeholder
      :questionKind
      :questionPurpose
      :targetsArtifact
      :targetsVersion
      :hasAnswerExpectation
      :hasFormalQuery
      :lifecycleState
      :reviewState
    }
    FILTER NOT EXISTS { ?question ?predicate ?value . }
  }
  FILTER NOT EXISTS {
    VALUES (?question ?expectedKind) {
      (ex:cq-first-class :ScopingQuestion)
      (ex:cq-traceability :ValidationQuestion)
      (ex:cq-target :ValidationQuestion)
      (ex:cq-expectation :ValidationQuestion)
      (ex:cq-execution :ValidationQuestion)
      (ex:cq-governance :ValidationQuestion)
      (ex:cq-patterns :ValidationQuestion)
      (ex:cq-template-elements :ValidationQuestion)
      (ex:cq-template-instantiation :ValidationQuestion)
      (ex:cq-recursion :ValidationQuestion)
      (ex:cq-bootstrap :ScopingQuestion)
      (ex:cq-satisfaction :ValidationQuestion)
      (ex:cq-current-evidence :ValidationQuestion)
      (ex:cq-coformalization :ValidationQuestion)
    }
    FILTER NOT EXISTS { ?question :questionKind ?expectedKind . }
  }
  FILTER NOT EXISTS {
    ?execution a :QueryExecution ;
               :evaluatesQuestion ?question ;
               :hasExecutionResult ?result .
    ?question :targetsVersion ?version .
    ?result :executionStatus :PassedStatus .
    FILTER NOT EXISTS { ?execution prov:used ?version . }
  }
  FILTER NOT EXISTS {
    ?execution a :QueryExecution ;
               :evaluatesQuestion ?question ;
               :hasExecutionResult ?result .
    ?question :hasAnswerExpectation ?expectation .
    ?expectation a :AnswerConstraint .
    FILTER NOT EXISTS {
      ?assessment a :ExpectationAssessment ;
                  :assessesResult ?result ;
                  :assessesExpectation ?expectation ;
                  :expectationSatisfied true .
    }
  }
  FILTER NOT EXISTS {
    ?template a :QuestionTemplate .
    FILTER NOT EXISTS {
      ?template :templateText ?templateText ;
                :hasTemplateElement ?element .
    }
  }
  FILTER NOT EXISTS {
    ?element a ?templateElementKind .
    VALUES ?templateElementKind {
      :TemplateElement
      :TemplateTextSegment
      :TemplateSlot
    }
    FILTER NOT EXISTS {
      ?template :hasTemplateElement ?element .
      ?element :elementIndex ?index .
      {
        ?element a :TemplateTextSegment ;
                 :segmentText ?value .
      }
      UNION
      {
        ?element a :TemplateSlot ;
                 :usesParameter ?value .
      }
    }
  }
  FILTER NOT EXISTS {
    ?template a :QuestionTemplate ;
              :hasTemplateElement ?left, ?right .
    ?left :elementIndex ?index .
    ?right :elementIndex ?index .
    FILTER(?left != ?right)
  }
  FILTER NOT EXISTS {
    ?template a :QuestionTemplate ;
              :hasTemplateElement ?element .
    ?element :elementIndex ?index .
    FILTER(?index > 0)
    FILTER NOT EXISTS {
      ?template :hasTemplateElement ?previous .
      ?previous :elementIndex ?previousIndex .
      FILTER(?previousIndex = ?index - 1)
    }
  }
  FILTER NOT EXISTS {
    ?parameter a :TemplateParameter .
    FILTER NOT EXISTS {
      ?template :hasTemplateParameter ?parameter ;
                :hasTemplateElement ?slot .
      ?parameter :parameterName ?parameterName .
      ?slot a :TemplateSlot ;
            :usesParameter ?parameter .
    }
  }
  FILTER NOT EXISTS {
    ?slot a :TemplateSlot ;
          :usesParameter ?parameter .
    ?template :hasTemplateElement ?slot .
    FILTER NOT EXISTS { ?template :hasTemplateParameter ?parameter . }
  }
  FILTER NOT EXISTS {
    ?template a :QuestionTemplate ;
              :hasTemplateParameter ?left, ?right .
    ?left :parameterName ?parameterName .
    ?right :parameterName ?parameterName .
    FILTER(?left != ?right)
  }
  FILTER NOT EXISTS {
    ?instantiation a :TemplateInstantiation .
    FILTER NOT EXISTS {
      ?question :hasTemplateInstantiation ?instantiation ;
                :hasFormulation ?formulation .
      ?instantiation :usesTemplate ?template ;
                     :realizesFormulation ?formulation .
    }
  }
  FILTER NOT EXISTS {
    ?instantiation a :TemplateInstantiation ;
                   :usesTemplate ?template .
    ?template :hasTemplateParameter ?parameter .
    FILTER NOT EXISTS {
      ?instantiation :hasTemplateBinding ?binding .
      ?binding :bindsParameter ?parameter .
    }
  }
  FILTER NOT EXISTS {
    ?instantiation a :TemplateInstantiation ;
                   :usesTemplate ?template ;
                   :hasTemplateBinding ?binding .
    ?binding :bindsParameter ?parameter .
    FILTER NOT EXISTS { ?template :hasTemplateParameter ?parameter . }
  }
  FILTER NOT EXISTS {
    ?instantiation a :TemplateInstantiation ;
                   :hasTemplateBinding ?left, ?right .
    ?left :bindsParameter ?parameter .
    ?right :bindsParameter ?parameter .
    FILTER(?left != ?right)
  }
  FILTER NOT EXISTS {
    ?binding a :TemplateBinding .
    {
      FILTER NOT EXISTS { ?instantiation :hasTemplateBinding ?binding . }
    }
    UNION
    {
      FILTER NOT EXISTS { ?binding :bindsParameter ?parameter . }
    }
    UNION
    {
      FILTER NOT EXISTS { ?binding :bindingText ?bindingText . }
    }
    UNION
    {
      FILTER NOT EXISTS {
        ?binding (:boundResource|:boundLiteral) ?boundValue .
      }
    }
    UNION
    {
      ?binding :boundResource ?boundResource ;
               :boundLiteral ?boundLiteral .
    }
  }
  FILTER NOT EXISTS {
    ?term a ?kind .
    VALUES ?kind { rdfs:Class rdf:Property }
    FILTER(STRSTARTS(STR(?term), STR(:)))
    FILTER(?term != :)
    FILTER NOT EXISTS {
      ?coverage a :CoverageAssertion ;
                :coveredResource ?term ;
                :coverageStatus :CoveredStatus .
    }
  }
}""" ;
    :usesFixture ex:self-application-fixture ;
    dcterms:title "Self-application boolean conformance query" ;
    dcat:downloadURL <https://ontology.inferal.com/modules/competency-question/queries/self-application-conformance.rq> .

ex:self-application-execution
    a :QueryExecution ;
    :executionOf ex:self-application-acceptance-query ;
    :evaluatesQuestion
        ex:cq-bootstrap ,
        ex:cq-coformalization ,
        ex:cq-current-evidence ,
        ex:cq-execution ,
        ex:cq-expectation ,
        ex:cq-first-class ,
        ex:cq-governance ,
        ex:cq-patterns ,
        ex:cq-recursion ,
        ex:cq-satisfaction ,
        ex:cq-target ,
        ex:cq-traceability ;
    :usesFixture ex:self-application-fixture ;
    :hasExecutionResult ex:self-application-result ;
    prov:used <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    prov:endedAtTime "2026-07-29T12:00:00Z"^^xsd:dateTime .

ex:self-application-result
    a :ExecutionResult ;
    :executionStatus :PassedStatus ;
    :resultCardinality "0"^^xsd:nonNegativeInteger ;
    :resultMessage "The checked-in acceptance query returned zero regression rows when run over the base ontology and this fixture." ;
    prov:wasGeneratedBy ex:self-application-execution .

ex:zero-regression-assessment
    a :ExpectationAssessment ;
    :assessesResult ex:self-application-result ;
    :assessesExpectation ex:constraint-zero-regressions ;
    :expectationSatisfied true .

# This independent execution is the evidence for the template-element CQ. Its
# row count is an observed result of the executable extraction query, not an
# inference from templateText or a SHACL validation outcome.
ex:template-element-extraction-execution
    a :QueryExecution ;
    :executionOf ex:template-element-extraction-query ;
    :evaluatesQuestion ex:cq-template-elements ;
    :usesFixture ex:self-application-fixture ;
    :hasExecutionResult ex:template-element-extraction-result ;
    prov:used <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    prov:endedAtTime "2026-07-29T12:00:30Z"^^xsd:dateTime .

ex:template-element-extraction-result
    a :ExecutionResult ;
    :executionStatus :PassedStatus ;
    :resultCardinality "20"^^xsd:nonNegativeInteger ;
    :resultMessage "The extraction query returned all twenty ordered elements from four self-application templates without parsing templateText." ;
    prov:wasGeneratedBy ex:template-element-extraction-execution .

# The realization query returns five ordered fragments for each of two exact
# instantiations. Tests concatenate those rows and compare them with the linked
# formulation literals; this result records the observed row count only.
ex:template-realization-execution
    a :QueryExecution ;
    :executionOf ex:template-realization-query ;
    :evaluatesQuestion ex:cq-template-instantiation ;
    :usesFixture ex:self-application-fixture ;
    :hasExecutionResult ex:template-realization-result ;
    prov:used <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    prov:endedAtTime "2026-07-29T12:00:45Z"^^xsd:dateTime .

ex:template-realization-result
    a :ExecutionResult ;
    :executionStatus :PassedStatus ;
    :resultCardinality "10"^^xsd:nonNegativeInteger ;
    :resultMessage "The realization query returned ten ordered fragments whose two concatenated sequences exactly match their linked formulations." ;
    prov:wasGeneratedBy ex:template-realization-execution .

ex:self-application-conformance-execution
    a :QueryExecution ;
    :executionOf ex:self-application-conformance-query ;
    :evaluatesQuestion ex:cq-coformalization ;
    :usesFixture ex:self-application-fixture ;
    :hasExecutionResult ex:self-application-conformance-result ;
    prov:used <https://ontology.inferal.com/modules/competency-question/versions/0.1.0> ;
    prov:endedAtTime "2026-07-29T12:01:00Z"^^xsd:dateTime .

ex:self-application-conformance-result
    a :ExecutionResult ;
    :executionStatus :PassedStatus ;
    :resultBoolean true ;
    :resultMessage "The alternate ASK formalization returned true over the same self-application graph." ;
    prov:wasGeneratedBy ex:self-application-conformance-execution .

# Public-term coverage. These claims are executable acceptance inputs: the
# query returns a regression row if a new public class or property lacks one.

ex:coverage-CompetencyQuestion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :CompetencyQuestion ; :coverageStatus :CoveredStatus .
ex:coverage-QuestionSet
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :QuestionSet ; :coverageStatus :CoveredStatus .
ex:coverage-QuestionFormulation
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :QuestionFormulation ; :coverageStatus :CoveredStatus .
ex:coverage-OntologyRequirement
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :OntologyRequirement ; :coverageStatus :CoveredStatus .
ex:coverage-UseCase
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :UseCase ; :coverageStatus :CoveredStatus .
ex:coverage-QuestionTemplate
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :QuestionTemplate ; :coverageStatus :CoveredStatus .
ex:coverage-TemplateElement
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-elements ; :coveredResource :TemplateElement ; :coverageStatus :CoveredStatus .
ex:coverage-TemplateTextSegment
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-elements ; :coveredResource :TemplateTextSegment ; :coverageStatus :CoveredStatus .
ex:coverage-TemplateSlot
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-elements ; :coveredResource :TemplateSlot ; :coverageStatus :CoveredStatus .
ex:coverage-TemplateParameter
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :TemplateParameter ; :coverageStatus :CoveredStatus .
ex:coverage-TemplateInstantiation
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :TemplateInstantiation ; :coverageStatus :CoveredStatus .
ex:coverage-TemplateBinding
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :TemplateBinding ; :coverageStatus :CoveredStatus .
ex:coverage-FormalQuery
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :FormalQuery ; :coverageStatus :CoveredStatus .
ex:coverage-TestFixture
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :TestFixture ; :coverageStatus :CoveredStatus .
ex:coverage-AnswerExpectation
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :AnswerExpectation ; :coverageStatus :CoveredStatus .
ex:coverage-ExpectedAnswer
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :ExpectedAnswer ; :coverageStatus :CoveredStatus .
ex:coverage-AnswerConstraint
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :AnswerConstraint ; :coverageStatus :CoveredStatus .
ex:coverage-QueryExecution
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :QueryExecution ; :coverageStatus :CoveredStatus .
ex:coverage-ExecutionResult
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :ExecutionResult ; :coverageStatus :CoveredStatus .
ex:coverage-ExpectationAssessment
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :ExpectationAssessment ; :coverageStatus :CoveredStatus .
ex:coverage-CoverageAssertion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :CoverageAssertion ; :coverageStatus :CoveredStatus .
ex:coverage-CompetencyQuestionKind
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :CompetencyQuestionKind ; :coverageStatus :CoveredStatus .
ex:coverage-QuestionPurpose
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :QuestionPurpose ; :coverageStatus :CoveredStatus .
ex:coverage-LifecycleState
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :LifecycleState ; :coverageStatus :CoveredStatus .
ex:coverage-ReviewState
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :ReviewState ; :coverageStatus :CoveredStatus .
ex:coverage-ExecutionStatus
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :ExecutionStatus ; :coverageStatus :CoveredStatus .
ex:coverage-CoverageStatus
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :CoverageStatus ; :coverageStatus :CoveredStatus .

ex:coverage-hasCompetencyQuestion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :hasCompetencyQuestion ; :coverageStatus :CoveredStatus .
ex:coverage-containsQuestion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :containsQuestion ; :coverageStatus :CoveredStatus .
ex:coverage-hasFormulation
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :hasFormulation ; :coverageStatus :CoveredStatus .
ex:coverage-formulationText
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :formulationText ; :coverageStatus :CoveredStatus .
ex:coverage-addressesRequirement
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :addressesRequirement ; :coverageStatus :CoveredStatus .
ex:coverage-requirementText
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :requirementText ; :coverageStatus :CoveredStatus .
ex:coverage-supportsUseCase
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :supportsUseCase ; :coverageStatus :CoveredStatus .
ex:coverage-useCaseText
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :useCaseText ; :coverageStatus :CoveredStatus .
ex:coverage-hasStakeholder
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :hasStakeholder ; :coverageStatus :CoveredStatus .
ex:coverage-questionKind
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :questionKind ; :coverageStatus :CoveredStatus .
ex:coverage-questionPurpose
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :questionPurpose ; :coverageStatus :CoveredStatus .
ex:coverage-targetsArtifact
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :targetsArtifact ; :coverageStatus :CoveredStatus .
ex:coverage-targetsVersion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :targetsVersion ; :coverageStatus :CoveredStatus .
ex:coverage-hasAnswerExpectation
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :hasAnswerExpectation ; :coverageStatus :CoveredStatus .
ex:coverage-hasFormalQuery
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :hasFormalQuery ; :coverageStatus :CoveredStatus .
ex:coverage-hasTemplateInstantiation
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :hasTemplateInstantiation ; :coverageStatus :CoveredStatus .
ex:coverage-hasTemplateElement
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-elements ; :coveredResource :hasTemplateElement ; :coverageStatus :CoveredStatus .
ex:coverage-hasTemplateParameter
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :hasTemplateParameter ; :coverageStatus :CoveredStatus .
ex:coverage-usesParameter
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :usesParameter ; :coverageStatus :CoveredStatus .
ex:coverage-usesTemplate
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :usesTemplate ; :coverageStatus :CoveredStatus .
ex:coverage-realizesFormulation
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :realizesFormulation ; :coverageStatus :CoveredStatus .
ex:coverage-hasTemplateBinding
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :hasTemplateBinding ; :coverageStatus :CoveredStatus .
ex:coverage-bindsParameter
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :bindsParameter ; :coverageStatus :CoveredStatus .
ex:coverage-lifecycleState
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :lifecycleState ; :coverageStatus :CoveredStatus .
ex:coverage-reviewState
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :reviewState ; :coverageStatus :CoveredStatus .
ex:coverage-templateText
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :templateText ; :coverageStatus :CoveredStatus .
ex:coverage-elementIndex
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-elements ; :coveredResource :elementIndex ; :coverageStatus :CoveredStatus .
ex:coverage-segmentText
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-elements ; :coveredResource :segmentText ; :coverageStatus :CoveredStatus .
ex:coverage-parameterName
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :parameterName ; :coverageStatus :CoveredStatus .
ex:coverage-parameterRole
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :parameterRole ; :coverageStatus :CoveredStatus .
ex:coverage-boundResource
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :boundResource ; :coverageStatus :CoveredStatus .
ex:coverage-boundLiteral
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :boundLiteral ; :coverageStatus :CoveredStatus .
ex:coverage-bindingText
    a :CoverageAssertion ; :coverageQuestion ex:cq-template-instantiation ; :coveredResource :bindingText ; :coverageStatus :CoveredStatus .
ex:coverage-queryText
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :queryText ; :coverageStatus :CoveredStatus .
ex:coverage-queryLanguage
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :queryLanguage ; :coverageStatus :CoveredStatus .
ex:coverage-usesFixture
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :usesFixture ; :coverageStatus :CoveredStatus .
ex:coverage-answerText
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :answerText ; :coverageStatus :CoveredStatus .
ex:coverage-answerResource
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :answerResource ; :coverageStatus :CoveredStatus .
ex:coverage-constraintExpression
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :constraintExpression ; :coverageStatus :CoveredStatus .
ex:coverage-constraintLanguage
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :constraintLanguage ; :coverageStatus :CoveredStatus .
ex:coverage-executionOf
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :executionOf ; :coverageStatus :CoveredStatus .
ex:coverage-evaluatesQuestion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :evaluatesQuestion ; :coverageStatus :CoveredStatus .
ex:coverage-hasExecutionResult
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :hasExecutionResult ; :coverageStatus :CoveredStatus .
ex:coverage-executionStatus
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :executionStatus ; :coverageStatus :CoveredStatus .
ex:coverage-resultMessage
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :resultMessage ; :coverageStatus :CoveredStatus .
ex:coverage-resultCardinality
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :resultCardinality ; :coverageStatus :CoveredStatus .
ex:coverage-resultBoolean
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :resultBoolean ; :coverageStatus :CoveredStatus .
ex:coverage-assessesResult
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :assessesResult ; :coverageStatus :CoveredStatus .
ex:coverage-assessesExpectation
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :assessesExpectation ; :coverageStatus :CoveredStatus .
ex:coverage-expectationSatisfied
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :expectationSatisfied ; :coverageStatus :CoveredStatus .
ex:coverage-coverageQuestion
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :coverageQuestion ; :coverageStatus :CoveredStatus .
ex:coverage-coveredResource
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :coveredResource ; :coverageStatus :CoveredStatus .
ex:coverage-coverageStatus
    a :CoverageAssertion ; :coverageQuestion ex:cq-recursion ; :coveredResource :coverageStatus ; :coverageStatus :CoveredStatus .