Graph-Driven city operations under ISO 5087

ISO 5087 is a graph-based city data standards series that unifies every key concept involved in urban services—assets, events, actors and regulations—under a single, interoperable vocabulary. Built to overcome the rigidity and siloed nature of earlier standards, it delivers a special-purpose, implementable specification whose semantics are encoded explicitly and without ambiguity, making machine reasoning and validation straightforward. Unlike generic reference models, ISO 5087 offers a unique, pragmatic interpretation of the smart-city domain, defining clear classes, properties and constraints that can be loaded directly into RDF/OWL graphs and queried with SPARQL. In short, it provides the missing lingua franca for Digital Twins and AI-driven operations, letting cities integrate data once and reuse it everywhere.

Table of contents

Fundamentals: the city as a resource graph

Modeling a city with RDF starts by viewing every urban element (street, traffic light, bus stop, sensor, even an administrative procedure) as a uniquely identified resource (URI). An RDF graph is a set of <subject, predicate, object> triples, embodying ISO 5087’s principle of “object and property identification” and its “intuitive information representation”.

The power of this graph approach is that relationships (predicates) are first-class citizens: we don’t just store attributes. We capture the fabric of dependencies among services ( hasStopOf ).

This yields three key advantages for a software engineer: extensibility (add classes without massive migrations), rich querying with SPARQL, and semantic alignment with other domains (IoT, BIM, GIS, etc..). Where relational models force expensive joins and rigid schemas, the graph keeps friction low when integrating heterogeneous feeds. The result is an urban data architecture that mirrors real-world complexity and becomes the bedrock for AI analytics, business rules, or Digital Twins.

Urban ontologies and the ISO 5087 series

With the RDF graph in place, we add explicit meaning through OWL ontologies. The ISO 5087 series supplies a specialized encoding that removes ambiguity and streamlines interoperability across city domains (transport, energy, environment).

In practice we define classes like iso5087:RoadSegment, object properties (iso5087:locatedIn) and cardinality constraints that guide data consumers. OWL supports inheritance, equivalence and logical descriptions that inference engines exploit to derive new knowledge (for instance, concluding that a luminaire is critical because it sits in a tunnel and its state is off).

This empowers urban-platform microservices to reason without ad-hoc rule code. From an engineering standpoint, a shared vocabulary slashes glue code, speeds teams onboarding and minimizes integration bugs. The standard’s “core-plus-extension” philosophy aligns with Domain-Driven Design: start with a stable core and extend with bounded contexts as new needs surface.

Quality, validation and inference: SHACL & SPARQL as AI allies

Urban graphs must be trustworthy and governed. ISO 5087 notes that data can be “validated with SHACL” and “inferred with SPARQL”.

With SHACL we write shapes that act like declarative unit tests: a charging station must have capacity ≥ 1, a sensor must reference a valid location, etc. These rules live in Git alongside code and run in CI/CD, ensuring production graphs don’t regress. SPARQL 1.1 supports CONSTRUCT and INSERT WHERE, letting us materialize views, enrich data from external sources or train Graph Machine Learning models without extra ETL. Outputs feed directly into AI frameworks to classify infrastructure states or forecast energy demand. This validation-inference-learning loop forms a reproducible pipeline that shortens time-to-insight and makes the graph a first-class citizen in the city’s MLOps architecture.

SHACL snippet – quality gate

1. Declares a NodeShape so every ex:ChargingStation must expose an integer ex:capacity ≥ 1.

2. When executed in the CI/CD pipeline, any station missing or violating that constraint fails validation, preventing bad data from reaching production.

# SHACL: a charging station must have at least one capacity point
@prefix ex: <http://example.com/city#> .
@prefix sh: <http://www.w3.org/ns/shacl#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

ex:ChargingStationShape
    a sh:NodeShape ;
    sh:targetClass ex:ChargingStation ;
    sh:property [
        sh:path ex:capacity ;        # ex:capacity ≥ 1
        sh:datatype xsd:integer ;
        sh:minInclusive 1 ;
        sh:minCount 1 ;
    ] .

SPARQL CONSTRUCT – real-time noise hotspots

1. Tags any location where live noise readings exceed 75 dB with the semantic class noiseHotspot.

2. Dashboards and ML models can consume this virtual layer to route night deliveries or trigger dynamic zoning.

CONSTRUCT {
    ?loc ex:status "noiseHotspot" ;
         ex:avgDb ?dB .
}
WHERE {
    ?sensor a ex:NoiseSensor ;
            ex:locatedAt ?loc ;
            ex:decibel ?dB .
    FILTER(?dB > 75)                     # 75 dB threshold
}

Hybrid SPARQL + Python – on-demand waste-collection optimizer

1. The SPARQL CONSTRUCT rule dynamically tags over-filled bins with collectionNeeded, enriching the live city graph.

2. Python pulls those tagged nodes, builds a street-graph, solves a Travelling-Salesman route starting at the depot, and triggers a truck dispatch—delivering data-driven, just-in-time waste pickup without manual scheduling.

# SPARQL 1.1: mark any waste bin that is >80 % full
CONSTRUCT {
    ?bin ex:status "collectionNeeded" .
}
WHERE {
    ?bin a ex:WasteBin ;
         ex:fillLevel ?pct .
    FILTER(?pct > 0.8)          # threshold
}

# pseudocode snippet
g = rdflib.Graph().parse("waste.ttl")
g += g.query(COLLECTION_QUERY)                       # add status triples

bins = [b for b in g.subjects(RDF.type, EX.WasteBin)
            if (b, EX.status, Literal("collectionNeeded")) in g]

street_net = build_street_graph("streets.ttl")      # from RDF roads
route = tsp_route(street_net, bins, depot="ex:Depot1")  # TSP solver
dispatch_truck(route)                               # send job to fleet

Digital Twins and predictive analytics on graphs

Other big goal is to enable Digital Twins that mirror the city in real time and let us simulate future scenarios. Anchoring the twin in an ISO 5087-compliant RDF graph gives every physical entity a logical mirror kept in sync via event streams (MQTT, Kafka). The graph’s “flexibility, agility and extensibility” (traits highlighted by the standard) mean new sensors or policies slot in without rebuilding the model. On this foundation, AI algorithms exploit the connected structure: detect traffic bottlenecks, semantic path-finding for evacuations, or time-series forecasting to optimize district boilers. The same graph acts as an orchestration backplane: simulations write hypothetical states, rule engines compare them to sustainability targets, and dashboards read live SPARQL views. The result is a sense-think-act cycle that surpasses mere monitoring, driving the city toward cognitive operation where decisions are verifiable, traceable and aligned with open standards. For software architects, that translates into lower coupling, higher automation, and the ability to iterate safely in a constantly evolving urban environment.