{
"path": "/3mafvxrfpqk2w",
"site": "at://did:plc:p7sxjpo2opcfkn7cgi5jqyqi/site.standard.publication/3m6ol2sdsnc2r",
"tags": [
"lex",
"ontology ",
"ai ",
"knowledgegraphs "
],
"$type": "site.standard.document",
"title": "Lex: A Formal Ontology Language for Property Graphs",
"content": {
"$type": "pub.leaflet.content",
"pages": [
{
"id": "019b3b1d-e51c-7886-be5d-c8dbc7249f30",
"$type": "pub.leaflet.pages.linearDocument",
"blocks": [
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": ""
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.image",
"image": {
"$type": "blob",
"ref": {
"$link": "bafkreie2n6gbmp5oumbs5svluxs6rpj2uizvqyxrr7mxczlutuitanrcge"
},
"mimeType": "image/png",
"size": 3868149
},
"aspectRatio": {
"width": 1536,
"height": 1024
}
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Property graphs have become the dominant paradigm for modeling connected data, yet they lack the formal semantic rigor that RDF/OWL brought to knowledge representation. While RDF graphs are constrained by their triple-based structure, property graphs offer richer modeling capabilities through typed edges with properties. However, this expressiveness comes at a cost: the absence of standardized formal semantics and constraint languages that can reason about graph structure and properties simultaneously."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 10,
"byteStart": 7
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Enter Lex (Logical Expression language for graphs) — a formal ontology language specifically designed for property graphs that brings the rigor of description logic to the flexibility of the property graph model."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "The Property Graph Gap"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Property graphs, popularized by systems like Neo4j, TigerGraph, and Amazon Neptune, represent knowledge as nodes and edges where both can carry arbitrary key-value properties. This model naturally captures real-world entities and relationships:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "(:Person {name: \"Alice\", age: 30})-[:KNOWS {since: 2015}]->(:Person {name: \"Bob\"})"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "However, property graphs traditionally lack:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.unorderedList",
"children": [
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 16,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Formal semantics for reasoning about graph structure"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 16,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Type constraints beyond simple labels"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 6,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Axioms that express logical relationships between patterns"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 15,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Inference rules that derive new knowledge from existing patterns"
},
"children": []
}
]
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "RDF/OWL provided these capabilities but forced everything into subject-predicate-object triples, making it awkward to represent multi-property relationships. Lex bridges this gap."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Core Concepts in Lex"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Node Types and Edge Types"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Lex treats node labels and edge types as first-class ontological concepts:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "NodeType Person { properties: { name: String [required], age: Integer [min: 0, max: 150], email: String [unique] }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "EdgeType KNOWS { source: Person, target: Person, properties: { since: Date [required], strength: Float [min: 0.0, max: 1.0] }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 57,
"byteStart": 35
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 110,
"byteStart": 93
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "This declaration establishes both structural constraints (what properties must exist) and value constraints (what ranges are valid)."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Property Constraints"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Lex supports rich property-level constraints beyond simple type checking:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "NodeType Employee extends Person { \n properties: { \nemployeeId: String [unique, pattern: /^EMP\\d{6}$/], \nsalary: Float [min: 0], \ndepartment: String [enum: [\"Engineering\", \"Sales\", \"HR\"]],\nmanager: Reference<Employee> [optional] }, \nconstraints: { \n// Self-reference constraint assert manager != self, \n // Cross-property constraint assert age >= 18, \n // Cardinality constraint assert count(outgoing(MANAGES)) <= 10 \n }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 46,
"byteStart": 23
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 87,
"byteStart": 65
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "These constraints are validated at write time and can trigger inference at read time."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Axioms: Deriving Knowledge from Structure"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Axioms in Lex define logical relationships between graph patterns. They enable reasoning about implicit knowledge based on explicit structure."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Transitivity Axioms"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom TransitiveAncestor { \npattern: (a:Person)-[:PARENT_OF]->(b:Person)-[:PARENT_OF]->(c:Person), \ninfers: (a)-[:ANCESTOR_OF]->(c)\n}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 145,
"byteStart": 134
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
}
],
"plaintext": "This axiom states: if A is parent of B, and B is parent of C, then A is an ancestor of C. The inference engine can materialize these ANCESTOR_OF edges or compute them on-demand."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Symmetry Axioms"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom SymmetricFriendship { \npattern: (a:Person)-[k:KNOWS {mutual: true}]->(b:Person), \n infers: (b)-[:KNOWS {mutual: true}]->(a)\n}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "When a mutual friendship exists in one direction, Lex ensures it exists in both."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Property Propagation Axioms"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom InheritCompanyRisk { \npattern: (e:Employee)-[:WORKS_FOR]->(c:Company {riskLevel: ?risk}), \ninfers: e.exposureRisk = ?risk}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 121,
"byteStart": 80
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "This propagates company risk levels to employees, demonstrating how axioms can derive node properties from graph context."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Existential Axioms"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom ManagerMustBeEmployee { \npattern: (e:Employee {manager: ?m}), \n requires: exists (m:Employee)}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "This ensures referential integrity: every manager reference must point to an actual Employee node."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Complex Constraints Through Path Patterns"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 36,
"byteStart": 14
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Lex supports path-based constraints that reason about graph structure:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "NodeType Department { \nproperties: { name: String [required], budget: Float }, constraints: { // No circular reporting structures assert not exists path (self)-[:REPORTS_TO*1..]->(self), // Must have at least one employee assert count(incoming(WORKS_IN)) >= 1, // Budget must cover salaries assert this.budget >= sum(incoming(WORKS_IN).source.salary) }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 9,
"byteStart": 5
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
},
{
"index": {
"byteEnd": 63,
"byteStart": 40
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "The path construct allows expressing topological constraints that prevent cycles, ensure connectivity, or validate hierarchical structures."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Temporal Axioms and Versioning"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Lex recognizes that knowledge graphs evolve over time:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "EdgeType EMPLOYED_BY { source: Person, target: Company, properties: { startDate: Date [required], endDate: Date [optional], role: String }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom CurrentEmployment { pattern: (p:Person)-[e:EMPLOYED_BY {endDate: null}]->(c:Company), infers: (p)-[:CURRENTLY_WORKS_FOR]->(c)}Constraint NoOverlappingEmployment { pattern: (p:Person)-[e1:EMPLOYED_BY]->(c1), (p)-[e2:EMPLOYED_BY]->(c2), requires: (e1.endDate < e2.startDate) OR (e2.endDate < e1.startDate) OR (e1 == e2)}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "These temporal patterns ensure employment periods don’t overlap and derive current employment status."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Probabilistic Axioms"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 77,
"byteStart": 54
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Unlike classical description logics, Lex can express probabilistic inference:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "ProbabilisticAxiom LikelyInterest { pattern: (p1:Person)-[:FOLLOWS]->(p2:Person)-[:INTERESTED_IN]->(t:Topic), infers: (p1)-[:MIGHT_LIKE {confidence: 0.6}]->(t), // Strength increases with shared connections boost: count((p1)-[:FOLLOWS]->(:Person)-[:INTERESTED_IN]->(t)) * 0.1}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "This creates weighted recommendations based on social graph patterns, where confidence scores accumulate through multiple paths."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Negation and Open World Assumptions"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 31,
"byteStart": 19
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
},
{
"index": {
"byteEnd": 70,
"byteStart": 60
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Lex supports both closed world (absence means false) and open world (absence means unknown) reasoning:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom NoKnownAllergies { pattern: (p:Person), requires: not exists (p)-[:ALLERGIC_TO]->(:Substance), infers: p.clearForAllIngredients = true, // Only valid under closed world assumption worldAssumption: closed(ALLERGIC_TO)}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 20,
"byteStart": 5
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#code"
}
]
}
],
"plaintext": "The worldAssumption annotation makes explicit when an axiom depends on complete information."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Integration with Dependent Types"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 105,
"byteStart": 72
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Given your interest in dependent type theory, Lex can be extended with dependent types on graph patterns:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "DependentNodeType Vector(dim: Nat) { properties: { components: Array<Float>[length: dim] }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "DependentEdType SIMILARITY(v1: Vector(?d1), v2: Vector(?d2)) where d1 == d2 { properties: { score: Float [min: -1.0, max: 1.0] }, constraints: { // Enforce computed similarity assert score == dotProduct(v1.components, v2.components) / (norm(v1.components) * norm(v2.components)) }}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 107,
"byteStart": 86
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "This ensures vectors can only be compared if they have matching dimensions, bringing type-level guarantees to graph operations."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Practical Implementation Considerations"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Lex ontologies compile to different enforcement strategies:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.unorderedList",
"children": [
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 16,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Eager validation: Constraints checked on write operations"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 22,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Materialized inference: Axioms computed and stored as new edges/properties"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 17,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Virtual inference: Axioms computed on-demand during queries"
},
"children": []
},
{
"$type": "pub.leaflet.blocks.unorderedList#listItem",
"content": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 17,
"byteStart": 0
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Hybrid approaches: Critical inferences materialized, others virtual"
},
"children": []
}
]
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "The choice depends on graph size, update frequency, and query patterns:"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.code",
"language": "plaintext",
"plaintext": "Axiom TransitiveAncestor { pattern: (a:Person)-[:PARENT_OF]->(b:Person)-[:PARENT_OF]->(c:Person), infers: (a)-[:ANCESTOR_OF]->(c), // Implementation hint strategy: materialized, updateTrigger: onChange(PARENT_OF)}"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Comparison with Existing Approaches"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "Press enter or click to view image in full size"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.image",
"image": {
"$type": "blob",
"ref": {
"$link": "bafkreiglzoohidtxcp5tobxpcgkebfrslxepxteieyjdkxul53pmxrt7ci"
},
"mimeType": "image/png",
"size": 183924
},
"aspectRatio": {
"width": 1400,
"height": 633
}
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.header",
"level": 2,
"facets": [],
"plaintext": "Conclusion"
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [
{
"index": {
"byteEnd": 244,
"byteStart": 214
},
"features": [
{
"$type": "pub.leaflet.richtext.facet#bold"
}
]
}
],
"plaintext": "Lex brings formal semantics to property graphs without sacrificing their expressive power. By supporting rich constraints, logical axioms, temporal patterns, and even dependent types, it provides a foundation for reasoning about connected data that goes beyond simple validation."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "For systems requiring both the flexibility of property graphs and the rigor of formal ontologies — whether in knowledge management, regulatory compliance, or agentic AI systems — Lex offers a path forward that doesn’t force choosing between expressiveness and correctness."
}
},
{
"$type": "pub.leaflet.pages.linearDocument#block",
"block": {
"$type": "pub.leaflet.blocks.text",
"facets": [],
"plaintext": "The language remains a research direction worth exploring as property graphs continue to dominate practical knowledge representation, yet increasingly demand the semantic guarantees that only formal ontologies can provide."
}
}
]
}
]
},
"bskyPostRef": {
"cid": "bafyreifyrnvu6xo3f2uplfj6v44hoyyuirz6molvuw5mp6haemn4hhkebu",
"uri": "at://did:plc:p7sxjpo2opcfkn7cgi5jqyqi/app.bsky.feed.post/3mafvxyngrs2w",
"commit": {
"cid": "bafyreihke4n7xjygquhbgnd5hc7jbzumotnim6jvz7burvzql6ooqh2vee",
"rev": "3mafvxyqhyh2c"
},
"validationStatus": "valid"
},
"description": "",
"publishedAt": "2025-12-20T09:40:19.938Z"
}