[Paper Review] Constructions from Dots and Lines

Marko A. Rodriguez, Peter Neubauer|arXiv (Cornell University)|Jun 11, 2010

Graph Theory and Algorithms11 references18 citations

TL;DR

This paper proposes a framework for modeling and querying complex relationships using property graphs—extensible, labeled, and attributed graphs that support diverse data types and relationships. By leveraging graph traversal languages like Gremlin, it enables expressive, path-based queries that simulate standard graph algorithms on virtual, implicit edges, allowing meaningful application of traditional algorithms to real-world, semantically rich data.

ABSTRACT

A graph is a data structure composed of dots (i.e. vertices) and lines (i.e. edges). The dots and lines of a graph can be organized into intricate arrangements. The ability for a graph to denote objects and their relationships to one another allow for a surprisingly large number of things to be modeled as a graph. From the dependencies that link software packages to the wood beams that provide the framing to a house, most anything has a corresponding graph representation. However, just because it is possible to represent something as a graph does not necessarily mean that its graph representation will be useful. If a modeler can leverage the plethora of tools and algorithms that store and process graphs, then such a mapping is worthwhile. This article explores the world of graphs in computing and exposes situations in which graphical models are beneficial.

Motivation & Objective

• To demonstrate how property graphs can model diverse real-world systems, from software dependencies to social networks.
• To address the limitations of traditional graph algorithms on labeled, attributed graphs by introducing a method to derive meaningful, virtual edges.
• To show that graph traversal frameworks can enable the application of standard graph algorithms to complex, semantically rich data structures.
• To provide a unified modeling approach that supports multiple graph types through extension of the property graph abstraction.

Proposed method

• Uses a property graph model that supports labeled vertices, labeled edges, and attributes on both vertices and edges.
• Employs a graph traversal language (Gremlin) to express complex queries as sequences of path operations, such as traversing outgoing edges, filtering by labels, and navigating to incoming vertices.
• Introduces the concept of a 'virtual edge' by interpreting a path through the graph as a derived, implicit edge with a specific semantic meaning (e.g., 'friend-of-a-friend').
• Applies standard graph algorithms (e.g., shortest path) to the derived virtual graph, which is effectively unlabeled and thus amenable to classical analysis.
• Uses variable assignment and set operations (e.g., except) in traversal expressions to avoid redundant results, such as excluding direct friends from friend-of-a-friend results.
• Demonstrates that by combining labeling, attributes, and traversal logic, a single property graph system can express multiple graph types (e.g., simple, weighted, RDF, hypergraphs).

Experimental results

Research questions

• RQ1 How can property graphs be used to model complex, real-world systems with diverse relationships and metadata?
• RQ2 What challenges arise when applying standard graph algorithms to labeled, attributed graphs, and how can they be overcome?
• RQ3 Can path-based traversals in a property graph be interpreted as virtual edges to enable the use of classical graph algorithms?
• RQ4 How can graph traversal frameworks support expressive, reusable queries that avoid common pitfalls like duplicate results in recursive relationships?
• RQ5 To what extent can a single graph model (e.g., property graph) generalize multiple graph types through configuration and abstraction?

Key findings

• The property graph model effectively generalizes multiple graph types, including simple graphs, weighted graphs, RDF graphs, and hypergraphs, by enabling or disabling specific features.
• Graph traversal languages like Gremlin allow for the construction of complex, semantic-aware queries that simulate virtual edges, enabling the use of standard graph algorithms on semantically rich data.
• By using variable assignment and set operations (e.g., g:except), traversal queries can exclude already-known results (e.g., direct friends), yielding more meaningful outcomes like non-overlapping friend-of-a-friend relationships.
• The interpretation of a path as a virtual edge creates an implicit, unlabeled graph over which classical graph algorithms can be meaningfully applied, preserving algorithmic integrity.
• The approach enables the modeling of intricate systems—such as social networks or software dependency graphs—while retaining the ability to analyze them with established graph-theoretic techniques.
• The framework demonstrates that even complex, real-world data with rich semantics can be processed efficiently using a single, extensible graph model and traversal language.