@prefix : <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#> .
@prefix schema: <http://schema.org/> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix prov: <http://www.w3.org/ns/prov#> .

<> a schema:CreativeWork ;
  schema:name "Open Knowledge Format as RDF Documents"@en ;
  schema:description """RDF-Turtle and HTML documentation collection derived from Google Cloud introduction of Open Knowledge Format. It models an RDF document alternative to Markdown OKF bundles, including ontology classes, ontology properties, instance documents, comparison dimensions, Linked Data principles, SPARQL recipes, FAQ, glossary, and provenance."""@en ;
  schema:dateCreated "2026-06-14T19:33:22Z"^^xsd:dateTime ;
  schema:dateModified "2026-06-14T19:33:22Z"^^xsd:dateTime ;
  schema:author <https://linkedin.com/in/kidehen#this> ;
  schema:about :analysis .

# schema:hasPart :
:analysis a schema:CreativeWork ;
  schema:name "Open Knowledge Format as RDF Documents"@en ;
  schema:about :article, :okfMarkdownPattern, :rdfTurtlePattern, :rdfBundle, :linkedDataPrinciples, :sparqlQuerying ;
  schema:isBasedOn :article ;
  schema:hasPart :ontology, :ontologyExamples, :rdfBundle, :comparison, :linkedDataPrinciples, :faq, :glossary, :howto, :benefitSet, :query-context-atoms, :query-comparison, :query-documents .

:article a schema:Article ;
  schema:name "Introducing the Open Knowledge Format"@en ;
  schema:headline "Introducing the Open Knowledge Format"@en ;
  schema:description """Google Cloud introduced Open Knowledge Format v0.1 as a vendor-neutral bundle of Markdown files with YAML frontmatter for portable agent and human knowledge."""@en ;
  schema:url <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/> ;
  schema:datePublished "2026-06-12"^^xsd:date ;
  schema:author :sam-mcveety, :amir-hormati ;
  schema:publisher :google-cloud ;
  schema:about :okfMarkdownPattern, :knowledgeCatalogIngestion, :agenticContext .

:ontology a owl:Ontology ;
  schema:name "RDF OKF Document Ontology"@en ;
  schema:description """Lightweight ontology for representing OKF-style context bundles as RDF-Turtle documents instead of Markdown files."""@en ;
  schema:identifier <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/> ;
  rdfs:label "RDF OKF Document Ontology"@en ;
  rdfs:comment """Defines classes and properties for RDF document bundles, semantic documents, context atoms, comparison dimensions, SPARQL recipes, and Linked Data principles."""@en ;
  schema:workExample :example-rdfKnowledgeBundle-class-axiom, :example-semanticDocument-class-axiom, :example-contextAtom-class-axiom, :example-comparisonDimension-class-axiom, :example-sparqlRecipe-class-axiom, :example-linkedDataPrinciple-class-axiom, :example-denotesResource-property-axiom, :example-hasContextAtom-property-axiom, :example-queryableBy-property-axiom, :example-contrastsWith-property-axiom, :example-implementsPrinciple-property-axiom .

:ontologyExamples a schema:CreativeWork ;
  schema:name "Ontology axiom examples"@en ;
  schema:description """Concrete Turtle examples showing valid instance usage for every custom ontology class and property axiom."""@en ;
  schema:hasPart :example-rdfKnowledgeBundle-class-axiom, :example-semanticDocument-class-axiom, :example-contextAtom-class-axiom, :example-comparisonDimension-class-axiom, :example-sparqlRecipe-class-axiom, :example-linkedDataPrinciple-class-axiom, :example-denotesResource-property-axiom, :example-hasContextAtom-property-axiom, :example-queryableBy-property-axiom, :example-contrastsWith-property-axiom, :example-implementsPrinciple-property-axiom ;
  schema:isPartOf :analysis .

:RdfKnowledgeBundle a rdfs:Class ;
  rdfs:label "RDF Knowledge Bundle"@en ;
  rdfs:comment """A deployable collection of RDF documents, ontologies, instance data, and query recipes that can be consumed by humans, agents, and SPARQL engines."""@en ;
  rdfs:subClassOf schema:CreativeWork ;
  schema:workExample :example-rdfKnowledgeBundle-class-axiom ;
  rdfs:isDefinedBy :ontology .

:SemanticDocument a rdfs:Class ;
  rdfs:label "Semantic Document"@en ;
  rdfs:comment """A document whose identity, type, metadata, body sections, and relationships are represented as RDF triples."""@en ;
  rdfs:subClassOf schema:DigitalDocument ;
  schema:workExample :example-semanticDocument-class-axiom ;
  rdfs:isDefinedBy :ontology .

:ContextAtom a rdfs:Class ;
  rdfs:label "Context Atom"@en ;
  rdfs:comment """A reusable unit of agent context such as a table, metric, runbook, API, dataset, join path, or concept."""@en ;
  rdfs:subClassOf schema:CreativeWork ;
  schema:workExample :example-contextAtom-class-axiom ;
  rdfs:isDefinedBy :ontology .

:ComparisonDimension a rdfs:Class ;
  rdfs:label "Comparison Dimension"@en ;
  rdfs:comment """A criterion used to compare OKF Markdown documents with RDF-Turtle documents."""@en ;
  rdfs:subClassOf schema:DefinedTerm ;
  schema:workExample :example-comparisonDimension-class-axiom ;
  rdfs:isDefinedBy :ontology .

:SparqlRecipe a rdfs:Class ;
  rdfs:label "SPARQL Recipe"@en ;
  rdfs:comment """A saved query over the RDF document collection."""@en ;
  rdfs:subClassOf schema:SoftwareSourceCode ;
  schema:workExample :example-sparqlRecipe-class-axiom ;
  rdfs:isDefinedBy :ontology .

:LinkedDataPrinciple a rdfs:Class ;
  rdfs:label "Linked Data Principle"@en ;
  rdfs:comment """A principle for naming, dereferencing, and interlinking entities on the Web."""@en ;
  rdfs:subClassOf schema:DefinedTerm ;
  schema:workExample :example-linkedDataPrinciple-class-axiom ;
  rdfs:isDefinedBy :ontology .

:denotesResource a rdf:Property ;
  rdfs:label "denotes resource"@en ;
  rdfs:comment """Connects a semantic document or context atom to the entity it identifies."""@en ;
  rdfs:domain :SemanticDocument ;
  rdfs:range :ContextAtom ;
  rdfs:subPropertyOf schema:about ;
  schema:workExample :example-denotesResource-property-axiom ;
  rdfs:isDefinedBy :ontology .

:hasContextAtom a rdf:Property ;
  rdfs:label "has context atom"@en ;
  rdfs:comment """Connects a bundle or document to a reusable unit of context."""@en ;
  rdfs:domain :RdfKnowledgeBundle ;
  rdfs:range :ContextAtom ;
  rdfs:subPropertyOf schema:hasPart ;
  schema:workExample :example-hasContextAtom-property-axiom ;
  rdfs:isDefinedBy :ontology .

:queryableBy a rdf:Property ;
  rdfs:label "queryable by"@en ;
  rdfs:comment """Connects a bundle or entity group to a SPARQL recipe."""@en ;
  rdfs:domain :RdfKnowledgeBundle ;
  rdfs:range :SparqlRecipe ;
  rdfs:subPropertyOf schema:hasPart ;
  schema:workExample :example-queryableBy-property-axiom ;
  rdfs:isDefinedBy :ontology .

:contrastsWith a rdf:Property ;
  rdfs:label "contrasts with"@en ;
  rdfs:comment """Connects one representation strategy to another in a comparison."""@en ;
  rdfs:domain :ComparisonDimension ;
  rdfs:range schema:CreativeWork ;
  rdfs:subPropertyOf schema:mentions ;
  schema:workExample :example-contrastsWith-property-axiom ;
  rdfs:isDefinedBy :ontology .

:implementsPrinciple a rdf:Property ;
  rdfs:label "implements principle"@en ;
  rdfs:comment """Connects an RDF document pattern to a Linked Data principle."""@en ;
  rdfs:domain schema:CreativeWork ;
  rdfs:range :LinkedDataPrinciple ;
  rdfs:subPropertyOf schema:about ;
  schema:workExample :example-implementsPrinciple-property-axiom ;
  rdfs:isDefinedBy :ontology .

:example-rdfKnowledgeBundle-class-axiom a schema:CreativeWork ;
  schema:name "Example: RDF Knowledge Bundle class axiom"@en ;
  schema:description """Shows a valid bundle instance with semantic documents, context atoms, and SPARQL recipes."""@en ;
  schema:about :RdfKnowledgeBundle ;
  schema:exampleOfWork :RdfKnowledgeBundle ;
  schema:text """:rdfBundle a :RdfKnowledgeBundle ;
  schema:hasPart :doc-sales-index ;
  :hasContextAtom :atom-bigquery-table ;
  :queryableBy :query-context-atoms ."""@en ;
  schema:mentions :rdfBundle, :doc-sales-index, :atom-bigquery-table, :query-context-atoms ;
  schema:isPartOf :ontologyExamples .

:example-semanticDocument-class-axiom a schema:CreativeWork ;
  schema:name "Example: Semantic Document class axiom"@en ;
  schema:description """Shows a semantic document instance denoting a reusable context resource."""@en ;
  schema:about :SemanticDocument ;
  schema:exampleOfWork :SemanticDocument ;
  schema:text """:doc-orders-table a :SemanticDocument ;
  schema:name "sales/tables/orders.ttl"@en ;
  :denotesResource :resource-orders-table ."""@en ;
  schema:mentions :doc-orders-table, :resource-orders-table ;
  schema:isPartOf :ontologyExamples .

:example-contextAtom-class-axiom a schema:CreativeWork ;
  schema:name "Example: Context Atom class axiom"@en ;
  schema:description """Shows a context atom as a reusable unit of agent context inside the RDF bundle."""@en ;
  schema:about :ContextAtom ;
  schema:exampleOfWork :ContextAtom ;
  schema:text """:atom-metric a :ContextAtom ;
  schema:name "Metric"@en ;
  schema:isPartOf :rdfBundle ."""@en ;
  schema:mentions :atom-metric, :rdfBundle ;
  schema:isPartOf :ontologyExamples .

:example-comparisonDimension-class-axiom a schema:CreativeWork ;
  schema:name "Example: Comparison Dimension class axiom"@en ;
  schema:description """Shows a comparison dimension contrasting the Markdown and RDF-Turtle representation patterns."""@en ;
  schema:about :ComparisonDimension ;
  schema:exampleOfWork :ComparisonDimension ;
  schema:text """:dim-query a :ComparisonDimension ;
  schema:name "Query model"@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern ."""@en ;
  schema:mentions :dim-query, :okfMarkdownPattern, :rdfTurtlePattern ;
  schema:isPartOf :ontologyExamples .

:example-sparqlRecipe-class-axiom a schema:CreativeWork ;
  schema:name "Example: SPARQL Recipe class axiom"@en ;
  schema:description """Shows a query recipe typed as both the local class and schema.org source code."""@en ;
  schema:about :SparqlRecipe ;
  schema:exampleOfWork :SparqlRecipe ;
  schema:text """:query-context-atoms a :SparqlRecipe, schema:SoftwareSourceCode ;
  schema:programmingLanguage "SPARQL"@en ;
  schema:target <https://linkeddata.uriburner.com/sparql> ."""@en ;
  schema:mentions :query-context-atoms ;
  schema:isPartOf :ontologyExamples .

:example-linkedDataPrinciple-class-axiom a schema:CreativeWork ;
  schema:name "Example: Linked Data Principle class axiom"@en ;
  schema:description """Shows a Linked Data principle represented as a reusable defined term in the collection."""@en ;
  schema:about :LinkedDataPrinciple ;
  schema:exampleOfWork :LinkedDataPrinciple ;
  schema:text """:principle-http-iris a :LinkedDataPrinciple ;
  schema:name "Use HTTP IRIs as names"@en ;
  schema:isPartOf :linkedDataPrinciples ."""@en ;
  schema:mentions :principle-http-iris, :linkedDataPrinciples ;
  schema:isPartOf :ontologyExamples .

:example-denotesResource-property-axiom a schema:CreativeWork ;
  schema:name "Example: denotes resource property axiom"@en ;
  schema:description """Shows the domain/range intent: a semantic document denotes a context atom."""@en ;
  schema:about :denotesResource ;
  schema:exampleOfWork :denotesResource ;
  schema:text """:doc-orders-table :denotesResource :resource-orders-table ."""@en ;
  schema:mentions :doc-orders-table, :resource-orders-table ;
  schema:isPartOf :ontologyExamples .

:example-hasContextAtom-property-axiom a schema:CreativeWork ;
  schema:name "Example: has context atom property axiom"@en ;
  schema:description """Shows the domain/range intent: a bundle contains a reusable context atom."""@en ;
  schema:about :hasContextAtom ;
  schema:exampleOfWork :hasContextAtom ;
  schema:text """:rdfBundle :hasContextAtom :atom-bigquery-table ."""@en ;
  schema:mentions :rdfBundle, :atom-bigquery-table ;
  schema:isPartOf :ontologyExamples .

:example-queryableBy-property-axiom a schema:CreativeWork ;
  schema:name "Example: queryable by property axiom"@en ;
  schema:description """Shows the domain/range intent: a bundle is queryable by a SPARQL recipe."""@en ;
  schema:about :queryableBy ;
  schema:exampleOfWork :queryableBy ;
  schema:text """:rdfBundle :queryableBy :query-context-atoms ."""@en ;
  schema:mentions :rdfBundle, :query-context-atoms ;
  schema:isPartOf :ontologyExamples .

:example-contrastsWith-property-axiom a schema:CreativeWork ;
  schema:name "Example: contrasts with property axiom"@en ;
  schema:description """Shows the comparison relationship between a dimension and the two representation patterns."""@en ;
  schema:about :contrastsWith ;
  schema:exampleOfWork :contrastsWith ;
  schema:text """:dim-query :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern ."""@en ;
  schema:mentions :dim-query, :okfMarkdownPattern, :rdfTurtlePattern ;
  schema:isPartOf :ontologyExamples .

:example-implementsPrinciple-property-axiom a schema:CreativeWork ;
  schema:name "Example: implements principle property axiom"@en ;
  schema:description """Shows an RDF document pattern implementing Linked Data principles."""@en ;
  schema:about :implementsPrinciple ;
  schema:exampleOfWork :implementsPrinciple ;
  schema:text """:rdfTurtlePattern :implementsPrinciple :principle-http-iris ."""@en ;
  schema:mentions :rdfTurtlePattern, :principle-http-iris ;
  schema:isPartOf :ontologyExamples .

:sam-mcveety a schema:Person ;
  schema:name "Sam McVeety"@en ;
  schema:description """Tech Lead, Data Analytics, Engineering, Data Cloud, Google Cloud, and co-author of the source article."""@en .

:amir-hormati a schema:Person ;
  schema:name "Amir Hormati"@en ;
  schema:description """Tech Lead, BigQuery, Engineering, Data Cloud, Google Cloud, and co-author of the source article."""@en .

:google-cloud a schema:Organization ;
  schema:name "Google Cloud"@en ;
  schema:description """Publisher of the Open Knowledge Format article and related data analytics tooling."""@en .

:bigquery a schema:Organization ;
  schema:name "BigQuery"@en ;
  schema:description """Google Cloud analytics platform mentioned through the OKF enrichment-agent reference implementation."""@en .

:knowledge-catalog a schema:Organization ;
  schema:name "Google Cloud Knowledge Catalog"@en ;
  schema:description """Google Cloud catalog system updated to ingest Open Knowledge Format and serve it to agents."""@en .

:okfMarkdownPattern a schema:CreativeWork ;
  schema:name "OKF Markdown document pattern"@en ;
  schema:description """The source article describes OKF v0.1 as a directory of Markdown files with YAML frontmatter fields including type, title, description, resource, tags, and timestamp."""@en .

:rdfTurtlePattern a schema:CreativeWork ;
  schema:name "RDF-Turtle document pattern"@en ;
  schema:description """This collection demonstrates an alternate pattern where each document is Turtle, every concept has an IRI, relationships are typed predicates, ontology terms are declared, and SPARQL recipes query the bundle."""@en ;
  :implementsPrinciple :principle-http-iris, :principle-dereference, :principle-rdf-description, :principle-links .

:rdfBundle a :RdfKnowledgeBundle ;
  schema:name "RDF OKF sales context bundle"@en ;
  schema:description """A sample RDF-Turtle bundle mirroring the article sales directory example with index, datasets, tables, metrics, and runbooks represented as semantic documents."""@en ;
  schema:hasPart :doc-sales-index, :doc-orders-dataset, :doc-orders-table, :doc-customers-table, :doc-weekly-active-users, :doc-incident-runbook ;
  :hasContextAtom :atom-bigquery-table, :atom-dataset, :atom-metric, :atom-join-path, :atom-runbook, :atom-api, :atom-provenance ;
  :queryableBy :query-context-atoms, :query-comparison, :query-documents .

:doc-sales-index a :SemanticDocument ;
  schema:name "sales/index.ttl"@en ;
  schema:description """Collection index for the sales context bundle."""@en ;
  schema:isPartOf :rdfBundle ;
  :denotesResource :resource-sales-index .

:resource-sales-index a :ContextAtom ;
  schema:name "sales/index"@en .

:doc-orders-dataset a :SemanticDocument ;
  schema:name "sales/datasets/orders_db.ttl"@en ;
  schema:description """Dataset profile for the sales orders database."""@en ;
  schema:isPartOf :rdfBundle ;
  :denotesResource :resource-orders-dataset .

:resource-orders-dataset a :ContextAtom ;
  schema:name "sales/datasets/orders_db"@en .

:doc-orders-table a :SemanticDocument ;
  schema:name "sales/tables/orders.ttl"@en ;
  schema:description """Table profile for completed customer orders."""@en ;
  schema:isPartOf :rdfBundle ;
  :denotesResource :resource-orders-table .

:resource-orders-table a :ContextAtom ;
  schema:name "sales/tables/orders"@en .

:doc-customers-table a :SemanticDocument ;
  schema:name "sales/tables/customers.ttl"@en ;
  schema:description """Table profile for customer records."""@en ;
  schema:isPartOf :rdfBundle ;
  :denotesResource :resource-customers-table .

:resource-customers-table a :ContextAtom ;
  schema:name "sales/tables/customers"@en .

:doc-weekly-active-users a :SemanticDocument ;
  schema:name "sales/metrics/weekly_active_users.ttl"@en ;
  schema:description """Metric definition and lineage for weekly active users."""@en ;
  schema:isPartOf :rdfBundle ;
  :denotesResource :resource-weekly-active-users .

:resource-weekly-active-users a :ContextAtom ;
  schema:name "sales/metrics/weekly_active_users"@en .

:doc-incident-runbook a :SemanticDocument ;
  schema:name "ops/runbooks/incident_response.ttl"@en ;
  schema:description """Runbook context for agent-assisted incident response."""@en ;
  schema:isPartOf :rdfBundle ;
  :denotesResource :resource-incident-runbook .

:resource-incident-runbook a :ContextAtom ;
  schema:name "ops/runbooks/incident_response"@en .

:atom-bigquery-table a :ContextAtom ;
  schema:name "BigQuery table"@en ;
  schema:description """A data warehouse table represented as a typed entity with schema, resource URL, owners, and relationships."""@en ;
  schema:isPartOf :rdfBundle .

:atom-dataset a :ContextAtom ;
  schema:name "Dataset"@en ;
  schema:description """A collection of tables, views, or data products with ownership and usage metadata."""@en ;
  schema:isPartOf :rdfBundle .

:atom-metric a :ContextAtom ;
  schema:name "Metric"@en ;
  schema:description """A reusable business measure with a formula, provenance, grain, source tables, and governance notes."""@en ;
  schema:isPartOf :rdfBundle .

:atom-join-path a :ContextAtom ;
  schema:name "Join path"@en ;
  schema:description """A relationship showing how two data entities are connected by keys or graph predicates."""@en ;
  schema:isPartOf :rdfBundle .

:atom-runbook a :ContextAtom ;
  schema:name "Runbook"@en ;
  schema:description """Operational instructions that agents can retrieve, traverse, and update."""@en ;
  schema:isPartOf :rdfBundle .

:atom-api a :ContextAtom ;
  schema:name "API"@en ;
  schema:description """A service interface represented as a discoverable entity with operations and examples."""@en ;
  schema:isPartOf :rdfBundle .

:atom-provenance a :ContextAtom ;
  schema:name "Provenance record"@en ;
  schema:description """A trace of source, author, timestamp, and derivation for a context atom."""@en ;
  schema:isPartOf :rdfBundle .

:claim-context-limits-agents a schema:Claim ;
  schema:name "Relevant context limits agentic systems"@en ;
  schema:claimReviewed """Foundation models can write code, summarize documents, and analyze data, but accurate action still depends on context."""@en ;
  schema:isPartOf :analysis .

:claim-okf-portable-format a schema:Claim ;
  schema:name "OKF formalizes the LLM-wiki pattern"@en ;
  schema:claimReviewed """OKF v0.1 turns a directory of Markdown files with YAML frontmatter into a portable, vendor-neutral knowledge format."""@en ;
  schema:isPartOf :analysis .

:claim-fragmented-context a schema:Claim ;
  schema:name "Enterprise context is fragmented"@en ;
  schema:claimReviewed """Schemas, metrics, runbooks, APIs, joins, code comments, documents, and expert memory live across incompatible surfaces."""@en ;
  schema:isPartOf :analysis .

:claim-format-not-service a schema:Claim ;
  schema:name "The problem needs a format, not another service"@en ;
  schema:claimReviewed """OKF emphasizes producer and consumer independence over a new runtime, SDK, or proprietary platform."""@en ;
  schema:isPartOf :analysis .

:claim-path-as-identity a schema:Claim ;
  schema:name "OKF uses file paths as concept identity"@en ;
  schema:claimReviewed """In the v0.1 design, each Markdown file represents a concept and the file path is the concept identity."""@en ;
  schema:isPartOf :analysis .

:claim-markdown-links-graph a schema:Claim ;
  schema:name "Markdown links make a graph"@en ;
  schema:claimReviewed """Concept documents link to each other with Markdown links, creating richer relationships than the directory tree alone."""@en ;
  schema:isPartOf :analysis .

:claim-open-evolution a schema:Claim ;
  schema:name "OKF is a starting point"@en ;
  schema:claimReviewed """The specification is intentionally versioned, open, and expected to evolve as producers and consumers appear."""@en ;
  schema:isPartOf :analysis .

:rdf-claim-iri-identity a schema:Claim ;
  schema:name "RDF upgrades path identity to Web identity"@en ;
  schema:claimReviewed """RDF-Turtle documents can use HTTP IRIs for concepts, allowing names to remain stable across repositories, products, and organizations."""@en ;
  schema:isPartOf :analysis .

:rdf-claim-typed-links a schema:Claim ;
  schema:name "RDF turns links into typed relationships"@en ;
  schema:claimReviewed """Markdown links say that two pages are connected; RDF predicates say how the entities are connected."""@en ;
  schema:isPartOf :analysis .

:rdf-claim-queryable-graph a schema:Claim ;
  schema:name "SPARQL makes the document collection queryable"@en ;
  schema:claimReviewed """SPARQL can query claims, types, provenance, relationships, and document metadata without bespoke parsers for every repository convention."""@en ;
  schema:isPartOf :analysis .

:rdf-claim-schema-evolution a schema:Claim ;
  schema:name "Ontologies support explicit schema evolution"@en ;
  schema:claimReviewed """RDF can publish classes and properties alongside instance data so extensions are visible and reusable."""@en ;
  schema:isPartOf :analysis .

:rdf-claim-linked-data a schema:Claim ;
  schema:name "Linked Data makes context portable beyond a bundle"@en ;
  schema:claimReviewed """Dereferenceable IRIs let a context atom join public or private graphs without translation into a vendor catalog schema."""@en ;
  schema:isPartOf :analysis .

:rdf-claim-human-readable a schema:Claim ;
  schema:name "Turtle remains inspectable text"@en ;
  schema:claimReviewed """RDF-Turtle keeps a readable text-file workflow while adding formal semantics, validation options, and graph querying."""@en ;
  schema:isPartOf :analysis .

:comparison a schema:CreativeWork ;
  schema:name "OKF Markdown vs RDF-Turtle comparison"@en ;
  schema:hasPart :dim-identity, :dim-links, :dim-query, :dim-portability, :dim-validation, :dim-evolution, :dim-human, :dim-agent .

:dim-identity a :ComparisonDimension ;
  schema:name "Identity"@en ;
  schema:description """OKF Markdown: file path is identity. RDF-Turtle: HTTP IRIs identify entities independent of local storage paths."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-links a :ComparisonDimension ;
  schema:name "Relationship semantics"@en ;
  schema:description """OKF Markdown: links are readable but mostly untyped. RDF-Turtle: predicates make relationships explicit and machine-actionable."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-query a :ComparisonDimension ;
  schema:name "Query model"@en ;
  schema:description """OKF Markdown: search tools and conventions. RDF-Turtle: SPARQL over typed triples, named graphs, provenance, and ontology terms."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-portability a :ComparisonDimension ;
  schema:name "Portability"@en ;
  schema:description """OKF Markdown: portable files and Git repositories. RDF-Turtle: portable files plus Web-scale entity references and graph federation."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-validation a :ComparisonDimension ;
  schema:name "Validation"@en ;
  schema:description """OKF Markdown: frontmatter fields and repository rules. RDF-Turtle: parser validation plus optional SHACL and ontology constraints."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-evolution a :ComparisonDimension ;
  schema:name "Schema evolution"@en ;
  schema:description """OKF Markdown: conventions evolve through spec versions. RDF-Turtle: ontologies publish classes and properties that can be extended incrementally."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-human a :ComparisonDimension ;
  schema:name "Human authoring"@en ;
  schema:description """OKF Markdown: familiar writing workflow. RDF-Turtle: more structured, but still text-based and readable when authored carefully."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:dim-agent a :ComparisonDimension ;
  schema:name "Agent consumption"@en ;
  schema:description """OKF Markdown: agents parse directories and frontmatter. RDF-Turtle: agents traverse typed graphs and execute SPARQL queries."""@en ;
  :contrastsWith :okfMarkdownPattern, :rdfTurtlePattern .

:linkedDataPrinciples a schema:CreativeWork ;
  schema:name "Linked Data principles for RDF OKF"@en ;
  schema:hasPart :principle-http-iris, :principle-dereference, :principle-rdf-description, :principle-links .

:principle-http-iris a :LinkedDataPrinciple ;
  schema:name "Use HTTP IRIs as names"@en ;
  schema:description """Things should be named with HTTP IRIs so people and agents can refer to the same entity across documents and systems."""@en ;
  schema:isPartOf :linkedDataPrinciples .

:principle-dereference a :LinkedDataPrinciple ;
  schema:name "Dereference names into descriptions"@en ;
  schema:description """Looking up an IRI should lead to useful information about the named entity."""@en ;
  schema:isPartOf :linkedDataPrinciples .

:principle-rdf-description a :LinkedDataPrinciple ;
  schema:name "Describe things with RDF"@en ;
  schema:description """Descriptions should use RDF statements so data from many sources can merge into one graph."""@en ;
  schema:isPartOf :linkedDataPrinciples .

:principle-links a :LinkedDataPrinciple ;
  schema:name "Include links to other things"@en ;
  schema:description """RDF should connect entities to other IRIs so graph discovery and reuse improve over time."""@en ;
  schema:isPartOf :linkedDataPrinciples .

:benefitSet a schema:DefinedTermSet ;
  schema:name "Benefits of RDF, Linked Data, and SPARQL"@en ;
  schema:hasDefinedTerm :benefit-global-join, :benefit-precision, :benefit-query, :benefit-provenance, :benefit-agent-planning, :benefit-no-sdk .

:benefit-global-join a schema:DefinedTerm ;
  schema:name "Global joinability"@en ;
  schema:description """A table, metric, runbook, and API can be related through IRIs rather than trapped in one repository tree."""@en ;
  schema:inDefinedTermSet :benefitSet .

:benefit-precision a schema:DefinedTerm ;
  schema:name "Precise relationship meaning"@en ;
  schema:description """Predicates distinguish schema:about, schema:isPartOf, prov:wasDerivedFrom, okfx:denotesResource, and business-specific links."""@en ;
  schema:inDefinedTermSet :benefitSet .

:benefit-query a schema:DefinedTerm ;
  schema:name "Cross-document questions"@en ;
  schema:description """SPARQL can ask which metrics depend on a deprecated table or which runbooks mention a failing API."""@en ;
  schema:inDefinedTermSet :benefitSet .

:benefit-provenance a schema:DefinedTerm ;
  schema:name "Provenance as data"@en ;
  schema:description """Authors, publication dates, derivations, source URLs, and generation steps can be queried rather than hidden in prose."""@en ;
  schema:inDefinedTermSet :benefitSet .

:benefit-agent-planning a schema:DefinedTerm ;
  schema:name "Agent planning substrate"@en ;
  schema:description """Agents can traverse known relationships, inspect ontology terms, and choose next actions from graph shape."""@en ;
  schema:inDefinedTermSet :benefitSet .

:benefit-no-sdk a schema:DefinedTerm ;
  schema:name "No required SDK"@en ;
  schema:description """Like OKF, Turtle files can live in Git, tarballs, object stores, or WebDAV, while remaining more formally queryable."""@en ;
  schema:inDefinedTermSet :benefitSet .

:faq a schema:FAQPage ;
  schema:name "FAQ: OKF as RDF documents"@en ;
  schema:mainEntity :q1, :q2, :q3, :q4, :q5, :q6, :q7, :q8, :q9, :q10 .

:q1 a schema:Question ;
  schema:name "What did Google Cloud introduce?"@en ;
  schema:acceptedAnswer :q1-answer .

:q1-answer a schema:Answer ;
  schema:text """Google Cloud introduced Open Knowledge Format v0.1, an open specification for representing agent and human knowledge as Markdown documents with YAML frontmatter."""@en .

:q2 a schema:Question ;
  schema:name "What problem does OKF address?"@en ;
  schema:acceptedAnswer :q2-answer .

:q2-answer a schema:Answer ;
  schema:text """OKF addresses fragmented enterprise context: schemas, metrics, runbooks, APIs, joins, documents, and expert knowledge split across incompatible systems."""@en .

:q3 a schema:Question ;
  schema:name "Why does this collection use RDF-Turtle instead of Markdown?"@en ;
  schema:acceptedAnswer :q3-answer .

:q3-answer a schema:Answer ;
  schema:text """It demonstrates how the same document-collection idea can be represented as linked, typed RDF documents with ontology and instance data."""@en .

:q4 a schema:Question ;
  schema:name "What is the main benefit of RDF over Markdown links?"@en ;
  schema:acceptedAnswer :q4-answer .

:q4-answer a schema:Answer ;
  schema:text """RDF links are typed predicates between identified things, so an agent can know whether a link means about, depends on, joins to, derives from, or implements."""@en .

:q5 a schema:Question ;
  schema:name "Does RDF replace OKF?"@en ;
  schema:acceptedAnswer :q5-answer .

:q5-answer a schema:Answer ;
  schema:text """Not necessarily. RDF can be an alternate OKF serialization, an enrichment layer, or the source-of-truth format for teams that need graph queries and Linked Data interoperability."""@en .

:q6 a schema:Question ;
  schema:name "Why are Linked Data principles important here?"@en ;
  schema:acceptedAnswer :q6-answer .

:q6-answer a schema:Answer ;
  schema:text """Linked Data makes context atoms portable beyond a local folder by using dereferenceable IRIs and RDF descriptions that can join other graphs."""@en .

:q7 a schema:Question ;
  schema:name "How does SPARQL improve agent consumption?"@en ;
  schema:acceptedAnswer :q7-answer .

:q7-answer a schema:Answer ;
  schema:text """SPARQL gives agents a standard way to ask graph-shaped questions across documents, types, relationships, provenance, and examples."""@en .

:q8 a schema:Question ;
  schema:name "What tradeoff does RDF introduce?"@en ;
  schema:acceptedAnswer :q8-answer .

:q8-answer a schema:Answer ;
  schema:text """RDF-Turtle is more explicit and structured than Markdown, which improves machine actionability but requires more care in authoring and validation."""@en .

:q9 a schema:Question ;
  schema:name "How can humans still read RDF docs?"@en ;
  schema:acceptedAnswer :q9-answer .

:q9-answer a schema:Answer ;
  schema:text """Turtle is a text format with prefixes, compact triples, labels, comments, and descriptions; a companion HTML view can provide the friendly reading surface."""@en .

:q10 a schema:Question ;
  schema:name "What should a practical RDF OKF bundle contain?"@en ;
  schema:acceptedAnswer :q10-answer .

:q10-answer a schema:Answer ;
  schema:text """It should contain ontology terms, typed instance documents, provenance, cross-links, glossary terms, query recipes, and a small set of conformance rules."""@en .

:glossary a schema:DefinedTermSet ;
  schema:name "Glossary: OKF RDF document collection"@en ;
  schema:hasDefinedTerm :term-okf, :term-rdf, :term-turtle, :term-linked-data, :term-sparql, :term-ontology, :term-named-graph, :term-shacl .

:term-okf a schema:DefinedTerm ;
  schema:name "Open Knowledge Format"@en ;
  schema:description """A Google Cloud open specification for portable Markdown-plus-frontmatter knowledge bundles for agents and humans."""@en ;
  schema:inDefinedTermSet :glossary .

:term-rdf a schema:DefinedTerm ;
  schema:name "RDF"@en ;
  schema:description """A W3C graph data model based on subject, predicate, object statements."""@en ;
  schema:inDefinedTermSet :glossary .

:term-turtle a schema:DefinedTerm ;
  schema:name "RDF-Turtle"@en ;
  schema:description """A compact, human-readable RDF serialization suitable for text-file document collections."""@en ;
  schema:inDefinedTermSet :glossary .

:term-linked-data a schema:DefinedTerm ;
  schema:name "Linked Data"@en ;
  schema:description """A set of Web practices for naming and interlinking things with dereferenceable IRIs and RDF descriptions."""@en ;
  schema:inDefinedTermSet :glossary .

:term-sparql a schema:DefinedTerm ;
  schema:name "SPARQL"@en ;
  schema:description """The standard query language and protocol for RDF graphs."""@en ;
  schema:inDefinedTermSet :glossary .

:term-ontology a schema:DefinedTerm ;
  schema:name "Ontology"@en ;
  schema:description """A published vocabulary of classes and properties that describes the meaning of graph data."""@en ;
  schema:inDefinedTermSet :glossary .

:term-named-graph a schema:DefinedTerm ;
  schema:name "Named graph"@en ;
  schema:description """An RDF graph identified by an IRI, useful for provenance, partitioning, and query scoping."""@en ;
  schema:inDefinedTermSet :glossary .

:term-shacl a schema:DefinedTerm ;
  schema:name "SHACL"@en ;
  schema:description """A W3C constraints language that can validate RDF graphs against shape rules."""@en ;
  schema:inDefinedTermSet :glossary .

:howto a schema:HowTo ;
  schema:name "How to build an RDF-Turtle OKF-style bundle"@en ;
  schema:step :step1, :step2, :step3, :step4, :step5, :step6, :step7, :step8 .

:step1 a schema:HowToStep ;
  schema:position "1"^^xsd:integer ;
  schema:name "Keep the folder bundle"@en ;
  schema:text """Preserve OKF’s simple bundle shape: directories, index documents, and version control still work for RDF-Turtle files."""@en .

:step2 a schema:HowToStep ;
  schema:position "2"^^xsd:integer ;
  schema:name "Mint stable IRIs"@en ;
  schema:text """Give every concept, metric, table, runbook, and API a durable HTTP IRI rather than relying only on a local file path."""@en .

:step3 a schema:HowToStep ;
  schema:position "3"^^xsd:integer ;
  schema:name "Declare the ontology"@en ;
  schema:text """Publish classes and properties for bundle, document, context atom, comparison dimension, and query recipe terms."""@en .

:step4 a schema:HowToStep ;
  schema:position "4"^^xsd:integer ;
  schema:name "Write instance data"@en ;
  schema:text """Represent each document as a named entity with type, title, description, source resource, tags, timestamps, and typed relationships."""@en .

:step5 a schema:HowToStep ;
  schema:position "5"^^xsd:integer ;
  schema:name "Type every relationship"@en ;
  schema:text """Replace ambiguous Markdown links with predicates such as schema:isPartOf, prov:wasDerivedFrom, okfx:denotesResource, and okfx:hasContextAtom."""@en .

:step6 a schema:HowToStep ;
  schema:position "6"^^xsd:integer ;
  schema:name "Add SPARQL recipes"@en ;
  schema:text """Store useful query patterns as first-class entities so agents can inspect, run, and adapt them."""@en .

:step7 a schema:HowToStep ;
  schema:position "7"^^xsd:integer ;
  schema:name "Render HTML from RDF"@en ;
  schema:text """Generate the human-friendly documentation view from the Turtle graph so prose and graph data stay aligned."""@en .

:step8 a schema:HowToStep ;
  schema:position "8"^^xsd:integer ;
  schema:name "Validate the graph"@en ;
  schema:text """Parse Turtle, test links, optionally apply SHACL shapes, and run example SPARQL queries before publishing."""@en .

:sparqlQuerying a schema:CreativeWork ;
  schema:name "SPARQL query layer for RDF OKF documents"@en ;
  schema:hasPart :query-context-atoms, :query-comparison, :query-documents .

:query-context-atoms a :SparqlRecipe, schema:SoftwareSourceCode ;
  schema:name "List context atoms"@en ;
  schema:programmingLanguage "SPARQL"@en ;
  schema:codeSampleType "SPARQL query recipe"@en ;
  schema:target <https://linkeddata.uriburner.com/sparql> ;
  schema:text """PREFIX schema: <http://schema.org/>
PREFIX okfx: <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#>

SELECT ?atom ?name ?description
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-knowledge-format-rdf-docs-gpt5-chat-1.ttl> {
    ?atom a okfx:ContextAtom ;
      schema:name ?name ;
      schema:description ?description .
  }
}
ORDER BY ?name"""@en .

:query-comparison a :SparqlRecipe, schema:SoftwareSourceCode ;
  schema:name "Compare OKF and RDF dimensions"@en ;
  schema:programmingLanguage "SPARQL"@en ;
  schema:codeSampleType "SPARQL query recipe"@en ;
  schema:target <https://linkeddata.uriburner.com/sparql> ;
  schema:text """PREFIX schema: <http://schema.org/>
PREFIX okfx: <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#>

SELECT ?dimension ?name ?description
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-knowledge-format-rdf-docs-gpt5-chat-1.ttl> {
    ?dimension a okfx:ComparisonDimension ;
      schema:name ?name ;
      schema:description ?description .
  }
}
ORDER BY ?name"""@en .

:query-documents a :SparqlRecipe, schema:SoftwareSourceCode ;
  schema:name "Find semantic documents and resources"@en ;
  schema:programmingLanguage "SPARQL"@en ;
  schema:codeSampleType "SPARQL query recipe"@en ;
  schema:target <https://linkeddata.uriburner.com/sparql> ;
  schema:text """PREFIX schema: <http://schema.org/>
PREFIX okfx: <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#>

SELECT ?doc ?name ?resource
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/open-knowledge-format-rdf-docs-gpt5-chat-1.ttl> {
    ?doc a okfx:SemanticDocument ;
      schema:name ?name .
    OPTIONAL { ?doc okfx:denotesResource ?resource }
  }
}
ORDER BY ?name"""@en .

:edge-1 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :is-based-on ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#article> ;
  schema:name "is based on"@en .

:edge-2 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#article> ;
  rdf:predicate :author ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#sam-mcveety> ;
  schema:name "author"@en .

:edge-3 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#article> ;
  rdf:predicate :author ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#amir-hormati> ;
  schema:name "author"@en .

:edge-4 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#article> ;
  rdf:predicate :publisher ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#google-cloud> ;
  schema:name "publisher"@en .

:edge-5 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#article> ;
  rdf:predicate :mentions ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#bigquery> ;
  schema:name "mentions"@en .

:edge-6 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#article> ;
  rdf:predicate :mentions ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#knowledge-catalog> ;
  schema:name "mentions"@en .

:edge-7 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-class ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#RdfKnowledgeBundle> ;
  schema:name "defines class"@en .

:edge-8 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-class ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#SemanticDocument> ;
  schema:name "defines class"@en .

:edge-9 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-class ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ContextAtom> ;
  schema:name "defines class"@en .

:edge-10 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-class ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ComparisonDimension> ;
  schema:name "defines class"@en .

:edge-11 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-class ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#SparqlRecipe> ;
  schema:name "defines class"@en .

:edge-12 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-class ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#LinkedDataPrinciple> ;
  schema:name "defines class"@en .

:edge-13 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-property ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#denotesResource> ;
  schema:name "defines property"@en .

:edge-14 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-property ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#hasContextAtom> ;
  schema:name "defines property"@en .

:edge-15 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-property ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#queryableBy> ;
  schema:name "defines property"@en .

:edge-16 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-property ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#contrastsWith> ;
  schema:name "defines property"@en .

:edge-17 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :defines-property ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#implementsPrinciple> ;
  schema:name "defines property"@en .

:edge-18 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-rdfKnowledgeBundle-class-axiom> ;
  schema:name "has example"@en .

:edge-19 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-semanticDocument-class-axiom> ;
  schema:name "has example"@en .

:edge-20 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-contextAtom-class-axiom> ;
  schema:name "has example"@en .

:edge-21 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-comparisonDimension-class-axiom> ;
  schema:name "has example"@en .

:edge-22 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-sparqlRecipe-class-axiom> ;
  schema:name "has example"@en .

:edge-23 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-linkedDataPrinciple-class-axiom> ;
  schema:name "has example"@en .

:edge-24 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-denotesResource-property-axiom> ;
  schema:name "has example"@en .

:edge-25 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-hasContextAtom-property-axiom> ;
  schema:name "has example"@en .

:edge-26 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-queryableBy-property-axiom> ;
  schema:name "has example"@en .

:edge-27 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-contrastsWith-property-axiom> ;
  schema:name "has example"@en .

:edge-28 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ontology> ;
  rdf:predicate :has-example ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-implementsPrinciple-property-axiom> ;
  schema:name "has example"@en .

:edge-29 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-rdfKnowledgeBundle-class-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#RdfKnowledgeBundle> ;
  schema:name "example of"@en .

:edge-30 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-semanticDocument-class-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#SemanticDocument> ;
  schema:name "example of"@en .

:edge-31 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-contextAtom-class-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ContextAtom> ;
  schema:name "example of"@en .

:edge-32 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-comparisonDimension-class-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#ComparisonDimension> ;
  schema:name "example of"@en .

:edge-33 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-sparqlRecipe-class-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#SparqlRecipe> ;
  schema:name "example of"@en .

:edge-34 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-linkedDataPrinciple-class-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#LinkedDataPrinciple> ;
  schema:name "example of"@en .

:edge-35 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-denotesResource-property-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#denotesResource> ;
  schema:name "example of"@en .

:edge-36 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-hasContextAtom-property-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#hasContextAtom> ;
  schema:name "example of"@en .

:edge-37 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-queryableBy-property-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#queryableBy> ;
  schema:name "example of"@en .

:edge-38 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-contrastsWith-property-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#contrastsWith> ;
  schema:name "example of"@en .

:edge-39 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#example-implementsPrinciple-property-axiom> ;
  rdf:predicate :example-of ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#implementsPrinciple> ;
  schema:name "example of"@en .

:edge-40 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-semantic-document ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-sales-index> ;
  schema:name "has semantic document"@en .

:edge-41 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-semantic-document ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-orders-dataset> ;
  schema:name "has semantic document"@en .

:edge-42 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-semantic-document ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-orders-table> ;
  schema:name "has semantic document"@en .

:edge-43 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-semantic-document ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-customers-table> ;
  schema:name "has semantic document"@en .

:edge-44 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-semantic-document ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-weekly-active-users> ;
  schema:name "has semantic document"@en .

:edge-45 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-semantic-document ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-incident-runbook> ;
  schema:name "has semantic document"@en .

:edge-46 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-bigquery-table> ;
  schema:name "has context atom"@en .

:edge-47 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-dataset> ;
  schema:name "has context atom"@en .

:edge-48 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-metric> ;
  schema:name "has context atom"@en .

:edge-49 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-join-path> ;
  schema:name "has context atom"@en .

:edge-50 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-runbook> ;
  schema:name "has context atom"@en .

:edge-51 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-api> ;
  schema:name "has context atom"@en .

:edge-52 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-context-atom ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-provenance> ;
  schema:name "has context atom"@en .

:edge-53 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-identity> ;
  schema:name "compares by"@en .

:edge-54 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-links> ;
  schema:name "compares by"@en .

:edge-55 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-query> ;
  schema:name "compares by"@en .

:edge-56 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-portability> ;
  schema:name "compares by"@en .

:edge-57 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-validation> ;
  schema:name "compares by"@en .

:edge-58 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-evolution> ;
  schema:name "compares by"@en .

:edge-59 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-human> ;
  schema:name "compares by"@en .

:edge-60 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :compares-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#dim-agent> ;
  schema:name "compares by"@en .

:edge-61 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :implements-principle ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#principle-http-iris> ;
  schema:name "implements principle"@en .

:edge-62 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :implements-principle ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#principle-dereference> ;
  schema:name "implements principle"@en .

:edge-63 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :implements-principle ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#principle-rdf-description> ;
  schema:name "implements principle"@en .

:edge-64 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :implements-principle ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#principle-links> ;
  schema:name "implements principle"@en .

:edge-65 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-benefit ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#benefit-global-join> ;
  schema:name "has benefit"@en .

:edge-66 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-benefit ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#benefit-precision> ;
  schema:name "has benefit"@en .

:edge-67 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-benefit ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#benefit-query> ;
  schema:name "has benefit"@en .

:edge-68 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-benefit ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#benefit-provenance> ;
  schema:name "has benefit"@en .

:edge-69 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-benefit ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#benefit-agent-planning> ;
  schema:name "has benefit"@en .

:edge-70 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :has-benefit ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#benefit-no-sdk> ;
  schema:name "has benefit"@en .

:edge-71 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :queryable-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#query-context-atoms> ;
  schema:name "queryable by"@en .

:edge-72 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :queryable-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#query-comparison> ;
  schema:name "queryable by"@en .

:edge-73 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#analysis> ;
  rdf:predicate :queryable-by ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#query-documents> ;
  schema:name "queryable by"@en .

:edge-74 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-orders-table> ;
  rdf:predicate :denotes-resource ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-bigquery-table> ;
  schema:name "denotes resource"@en .

:edge-75 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-weekly-active-users> ;
  rdf:predicate :denotes-resource ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-metric> ;
  schema:name "denotes resource"@en .

:edge-76 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#doc-weekly-active-users> ;
  rdf:predicate :depends-on ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#atom-join-path> ;
  schema:name "depends on"@en .

:edge-77 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#rdf-claim-iri-identity> ;
  rdf:predicate :implements-principle ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#principle-http-iris> ;
  schema:name "implements principle"@en .

:edge-78 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#rdf-claim-linked-data> ;
  rdf:predicate :implements-principle ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#principle-links> ;
  schema:name "implements principle"@en .

:edge-79 a rdf:Statement ;
  rdf:subject <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#rdf-claim-queryable-graph> ;
  rdf:predicate :about ;
  rdf:object <https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing/#term-sparql> ;
  schema:name "about"@en .