Pith. sign in

REVIEW 4 major objections 5 minor 41 references

Graph-Native Normalization

T0 review · 4 major / 5 minor · reviewed 2026-08-02 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A new framework rewrites any labeled property graph so that each fact is stored once, without losing information or the original dependencies.

desk verdict First real attempt at edge-aware normalization for LPGs, with honest artifacts and a solid comparison to [36], but the formal core as printed does not prove the lossless, dependency-preserving guarantees that the main claim rests on. read the letter →

arxiv 2603.02995 v3 pith:IWXW2TNQ submitted 2026-03-03 cs.DB

Johannes Schrott , Maxime Jakubowski , Katja Hose This is my paper
classification cs.DB
keywords knowledgegraphslabeledpropertygraphnormalizationfunctionaldependenciesredundancygraph-nativenormalformstransformationsdataquality
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper proposes graph-native normalization for labeled property graphs, extending functional-dependency normalization from nodes to edges and to dependencies that mix nodes and edges. The central claim is that a new dependency type—graph object functional dependencies (GO-FDs)—can express all three kinds of dependencies, and that the accompanying graph transformations are lossless and dependency-preserving. If correct, any graph plus a curated set of GO-FDs can be rewritten into a graph-native normal form where every redundancy potential is 1, meaning no fact is stored twice. The paper also shows experimentally that this reduces redundancy across a range of real and synthetic graphs, while the effect on query performance is mixed; direct queries with optimal rewriting consistently improve.

What carries the argument

The central objects are graph object functional dependencies (GO-FDs) and the graph transformations of Table 4. A GO-FD Q :: X ⇒ Y says that within the subgraphs matched by pattern Q, the values of X determine the values of Y. The Table 4 transformations bundle the determining and determined variables into a new node, keyed by X, and connect it to the original object—reifying the edge when the dependency originates from an edge. These transformations, orchestrated by the scoped and full normalization algorithms, are what carry the reduction of redundancy.

What would settle it

Construct a small labeled property graph with a within-edge dependency, for example two edges with the same group number but different group names, apply the corresponding transformation, and check whether the dependency still holds after transforming back (by joining the reified nodes with the original edges). A failure would be a graph where two distinct reifier nodes point to different value nodes for the same key, or where joining the decomposed structures yields tuples that were not in the original graph. Separately, to test the Transitivity rule, pick scopes Q and Q' with Q ⊑ Q' and depe

Watch

Extended reading notes

Core claim

The paper defines GO-FDs, which pair a graph pattern (the scope) with a functional dependency over object identities and property variables. This lets dependencies be stated within nodes, within edges, or between an edge and its endpoint node. It then identifies redundancy patterns—dependency shapes that can lead to the same fact being represented multiple times—and gives a family of graph transformations (Table 4) that restructure the graph to remove them. The transformations mirror lossless, dependency-preserving relational decompositions, but operate natively on graphs, using reification when a dependency's left-hand side involves an edge. Two algorithms apply these transformations scope

Load-bearing premise

The normalization guarantee rests on the informal equivalence between the graph transformations of Table 4 and the lossless, dependency-preserving relational decompositions of Table 5; if that equivalence fails, the claims that the transformations are lossless and dependency-preserving—and hence that the final graph is in GN-NF—do not follow, and the printed Transitivity rule in Section 4 is unsound as stated, so the completeness theorem is not supported as printed.

Editorial extensions

If this is right

  • If the claims hold, any labeled property graph with a finite set of GO-FDs can be normalized so that every redundancy potential equals 1, eliminating update anomalies and inconsistencies from duplicated facts.
  • The approach subsumes node-only normalization as a special case, so existing normalized graphs remain normalized, while newly covered within-edge and between-object dependencies are also handled.
  • Direct queries that target the normalized fact—rewritten to hit the new keyed node—should run faster and with fewer database hits than on the original graph, because each fact is looked up once.
  • Normalization generally increases the number of nodes and edges, so the tradeoff between structural simplicity and redundancy reduction is inherent; the paper argues both cannot be optimized simultaneously.
  • The transformation rules suggest a principled way to migrate an existing graph to a schema that respects declared functional dependencies, without manual restructuring.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural testable extension is to automate GO-FD discovery: the paper notes that manual curation is currently required, and mining FDs over graph patterns is an open problem; a mining algorithm that proposes candidate GO-FDs from a graph would make the normalization pipeline practical at scale.
  • The reification pattern used for edge-derived dependencies is a generic technique that could also be applied to queries or views over edge properties, not just to physical schema design, since it converts edge-local facts into node-local facts that can be indexed.
  • The paper's results suggest that optimal query rewriting is as important as the normalization itself; a future system could automatically rewrite incoming queries against the normalized schema, similar to view adaptation, rather than requiring users to know the new structure.
  • If the lossless equivalence between graph transformations and relational decompositions can be made fully rigorous, the approach might extend to other graph data models, including RDF, as the paper indicates as future work.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper proposes a normalization framework for labeled property graphs (LPGs) that goes beyond the existing within-node approach of Skavantzos and Link. It introduces Graph Object Functional Dependencies (GO-FDs), which can express dependencies within nodes, within edges, and between nodes and edges; defines scoped and global graph-native normal forms (GN-3NF, GN-BCNF); and gives two algorithms that apply graph transformations to eliminate redundancy patterns. The authors claim that the transformations are lossless and dependency-preserving, so that after normalization every redundancy potential equals 1. The evaluation applies the algorithms to six datasets with manually curated GO-FD schemas and studies structural metrics, redundancy metrics, and query performance, comparing against the earlier within-node approach on the scenarios where the latter applies.

Significance. If the formal claims are correct, this is a useful extension of relational-style normalization to property graphs, addressing a real gap: dependencies on edge properties and between objects are not expressible in the prior gFD framework. The paper is also unusually concrete in shipping artifacts and in providing a comparison to [36] on shared within-node scenarios, which gives the within-node part external grounding. However, the central correctness argument is currently not established. The semantics of pattern matching in Table 1 is inconsistent with the paper's own inclusion order and examples; the stated Transitivity rule is unsound, so Theorem 4.4 and the minimal-cover phase are unsupported; and the losslessness/dependency-preservation of the graph transformations is argued only by analogy with relational decomposition, with no formal invariant between graph states and the decomposed relations. These are load-bearing issues for the paper's main guarantee. The experimental redundancy metrics after normalization are 1 by construction of the transformations, so they serve as a consistency check rather than an independent validation; the query-performance results are informative b

major comments (4)
  1. [Table 1 and Lemma 4.3] The evaluation of a node pattern (x:L:P) is defined as lab(n) ⊆ L, i.e., the matched node may have no labels outside L. This contradicts the paper's own usage: Example 6.1 treats (x:{Course,International}:P) as more specific than (x:{Course}:P), which requires the opposite semantics, L ⊆ lab(n). The inclusion conditions in Table 3 and the Restriction rule also presuppose that adding labels makes a pattern more specific. With the printed subset direction, (x:{Course}:P) and (x:{Course,International}:P) are incomparable, and Phase 1 of Algorithm 1 would not collect the intended dependencies. This needs to be corrected throughout, since the semantics of GO-FDs and the soundness of Restriction depend on it.
  2. [Section 4, Transitivity rule] The rule is stated as: from Q::X⇒Y and Q'::Y⇒Z with Q⊑Q', infer Q'::X⇒Z. This is unsound. Since Q is more specific than Q', the first premise only constrains matches of Q, not all matches of Q'. A counterexample: let Q' match all nodes with property p and q, Q match only nodes with an additional label; suppose within Q, p determines q, and globally q determines z, but outside Q two nodes agree on p while disagreeing on q. The premises hold but Q'::p⇒z fails. A sound version would need the first premise on the more general scope Q'. As printed, Theorem 4.4 is false, and the minimal-cover computation in Algorithm 1 Phase 2, which relies on Armstrong-style reasoning over restricted dependencies, is not justified.
  3. [Section 5.2, Table 5] The claim that the graph transformations of Table 4 are lossless and dependency-preserving is supported only by an analogy: because the relational decomposition in Table 5 is lossless, 'we can say that the transformations are lossless' (just before Example 5.4). No formal invariant relates graphs before and after a transformation to the decomposed relations used in Table 5, and the create/remove semantics of graph transformations is described informally. The subsequent guarantee in Algorithm 2 that the output graph is in GN-NF depends directly on this equivalence. A proof or at least a precise statement of the correspondence (e.g., via an interpretation of the transformed graph into the decomposed relations) is needed. Without it, the main normalization theorem is not established.
  4. [Section 7, Table 9] The redundancy metrics (mMaxRed.Pot, mAvgRed.Pot, mMinim) after normalization are all reported as 1. This is by design: the transformations group tuples by X∪Y and create a new object keyed by X, so each value combination occurs exactly once. The evaluation therefore verifies that the implementation executes the intended rewriting, but it does not independently test whether the normalization is lossless or dependency-preserving. A comparison of query answers or data reconstruction before/after normalization would strengthen the losslessness claim. The comparison with [36] on within-node scenarios is helpful, but it does not validate the new between-object transformations.
minor comments (5)
  1. [Definition 5.6] GN-2NF is vacuous: since the structurally implied Object Identity axiom gives every object o as a key for every property o.k, every property is fully dependent on a key in any graph. If GN-2NF is intended to mirror the relational definition, it should require full dependence on every key, or otherwise the definition should be clarified.
  2. [Table 4, row ψ_between-ep-n] The resolved pattern for ψ_between-ep-n shows a constructed node ⟨y k2⟩, while the descriptor uses property k1 and the Table 5 rationale refers to k1. This appears to be a typo; it should be ⟨y k1⟩.
  3. [Algorithm 1, Phase 3] The loop 'for Y' ⊆ YZ do' is confusing. Since the preceding paragraph says each RHS is decomposed to a single variable, the loop should iterate over singleton subsets of the original RHS, not arbitrary subsets. Please rephrase to avoid ambiguity.
  4. [Theorem 5.2 / Figure 5] The statement that 'all other dependency shapes allow for redundancies' is asserted without a proof of exhaustiveness. Since Table 4 is later used as the complete set of redundancy patterns, a short argument or reference for this classification would be needed.
  5. [Section 6.1, Phase 1] The text refers to 'Theorem 4.3' for the inclusion check, but the result is numbered Lemma 4.3.

Circularity Check

1 steps flagged · score 2.0 of 10

No significant circularity; the only by-construction element is the post-normalization redundancy metric, which is presented as a consistency check rather than an independent prediction.

  1. other [Section 7, 'Redundancy Reduction', Table 9]
    "After performing graph-native normalization, i.e., performing the redundancy removing transformations (cf. Section 5), all redundancies are eliminated. Thus, the per-GO-FD metrics mMaxRed.Pot., mAvgRed.Pot., and mMinim all return 1, as for each dependency φ : Q :: X⇒Y there is only a single combination of values for the property keys in X and Y."

    The redundancy-removing transformations are defined precisely so that the descriptor attributes X∪Y are moved into a new node keyed by X, with a new key constraint. Consequently, the group-by-count of X∪Y after normalization is 1 by construction. The 'all return 1' result is therefore a consistency check of the transformation design, not an independently testable prediction. This is a mild, local by-construction element; it does not affect the paper's main formal contribution of defining GO-FDs, GN-NFs, and the transformation rules.

full rationale

The paper's central derivation—GO-FDs, GN-NFs, and the Table 4 transformations—is self-contained and does not reduce to its inputs. The losslessness and dependency-preservation claims are supported by an analogy to relational decompositions (Table 5); this is an informal transfer, and the unsound Transitivity rule is a correctness gap, but neither is circularity. The comparison with Skavantzos and Link [36] on within-node scenarios provides external grounding, and the use of author-provided datasets (London Public Transport, Train Services) is an evaluation choice, not a load-bearing self-citation. The only by-construction element is the redundancy metric after normalization equaling 1, which follows from the transformations' definitions; the paper frames this as verification, not as an independent prediction. Overall, the derivation chain is not circular.

Assumptions & free parameters 1 free parameters · 6 assumptions · 2 invented entities

The central formalism introduces no fitted numeric parameters: GO-FDs are user-supplied constraints, and Skolem constructors derive new identities from data values. The load-bearing inputs are the manual GO-FD bases, the restriction to three basic pattern shapes and strict GO-FDs, and the unproven classification of redundancy shapes as exhaustive. No invented entities with external falsifiable handles are introduced; reifier nodes and Skolem labels are method-internal artifacts.

free parameters (1)
  • Manual GO-FD bases per evaluation scenario = N/A — curated constraint sets, not numeric values
    The dependency sets are hand-defined per dataset and scenarios were selected to cover all six transformation types, so the redundancy-reduction and query results measure the behavior of the transformations on curated inputs rather than an independently discovered property.
assumptions (6)
  • standard math Relational normalization theory: Armstrong's axioms, lossless-join and dependency-preserving decomposition, synthesis algorithm guarantees 3NF.
    Invoked in Sections 4-6 to compute minimal covers and to argue transformation losslessness; the paper reduces within-scope reasoning to the relational case.
  • standard math Completeness of Hellings et al.'s [17] axiomatization of Functional Constraints over n-ary relations, and the encodability of LPGs into a single 4-ary relation and of GO-FDs into FCs.
    Used in the proof sketch of Theorem 4.4; the encoding is asserted, not shown.
  • domain assumption Labeled property graph patterns follow GPC semantics in which required labels and property keys are present in matched objects (lab(n) ⊇ L).
    The paper's examples and GQL-compatibility claim depend on this; Table 1 as printed says lab(n) ⊆ L, an inconsistency in the text.
  • domain assumption Only basic graph patterns without repetitions are needed as scopes (three pattern shapes of Table 3).
    The formalism is restricted to these shapes; Section 8 lists broader patterns as future work.
  • ad hoc to paper Strict GO-FDs (at most one object identity variable per side of the descriptor) suffice to capture natural dependencies.
    Introduced in Section 5.1 to simplify the discussion of redundancies; normal forms and transformations are developed only for strict GO-FDs, limiting the claimed generality.
  • ad hoc to paper The classification of dependency shapes in Figure 5 (no-redundancy) and Table 4 (redundancy patterns) is exhaustive.
    The paper asserts all other shapes allow redundancies but gives no enumeration proof.
invented entities (2)
  • Reifier nodes (⟨y⟩ in transformations ψ_within-e, ψ_between-ep-np, ψ_between-ep-n)
    purpose: Provide a node endpoint so that an edge's properties can be attached to a new fact-node; LPG edges cannot be endpoints of other edges.
    Method-internal modeling artifact; no falsifiable handle outside the method.
  • Skolem-constructed node identities and labels (⟨Lk1⟩, label Lk1; e.g., 'Ccolorclinectype' in evaluation queries)
    purpose: Create merged fact-nodes identified by the LHS values of a GO-FD so identical facts collapse to one node.
    Method-internal construction; deterministic but opaque, and users must know the generated labels to write optimal query rewrites.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Graph-Native Normalization." pith.science (2026). https://pith.science/paper/IWXW2TNQ

@misc{pith2026260302995,
  author       = {Pith},
  title        = {Pith review of: Graph-Native Normalization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IWXW2TNQ}},
  note         = {Machine review of arXiv:2603.02995}
}
read the original abstract

In recent years, knowledge graphs (KGs) - in particular in the form of labeled property graphs (LPGs) - have become essential components in a broad range of applications. Although the absence of strict schemas for KGs facilitates structural issues that lead to redundancies and subsequently to inconsistencies and anomalies, the problem of KG quality has so far received only little attention. Inspired by normalization using functional dependencies for relational data, a first approach exploiting dependencies within nodes has been proposed. However, real-world KGs also expose functional dependencies involving edges. In this paper, we therefore propose graph-native normalization, which considers dependencies within nodes, edges, and their combination. We define a range of graph-native normal forms and graph object functional dependencies and propose algorithms for transforming graphs accordingly. We evaluate our contributions using a broad range of synthetic and native graph datasets.

Figures

Figures reproduced from arXiv: 2603.02995 by the authors.

Figure 1
Figure 1. Examples of denormalized LPGs describing courses, lecturers, and students. Redundancies are ............... underlined....... with ...... dots. :Course n1 title: “Database Systems” language: “English” .............. usingBook: . ......... “Alice” :Lecturer n3 :teaches e2 at: 2026-02-16 name: “Maxime” :Lecturer n2 :teaches e1 at: 2026-02-09 name: “Johannes” :Lecturer n4 :teaches e3 at: 2026-02-23 name: “Katja” [PITH… view at source ↗
Figure 4
Figure 4. Resolving redundancies in Figure 1 related to [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figure 5
Figure 5. GO-FDs of different shapes for which no redun [PITH_FULL_IMAGE:figures/full_fig_p006_5.png] view at source ↗
Figures from the paper (3 more)
Figure 6
Figure 6. Figure 6: Example graph for the calculation of per [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: Percentual changes (log scale) to our structural per-graph metrics following graph-native [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Comparison of query performance (𝑚Q.DBHit) be￾tween original and rewritten queries the average number of properties but, due to reification, create substantially more new nodes and edges. Overall, Figure 7a shows that graph-native normalization almost always increases …

Review history (2 revisions) →

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

41 extracted references

  1. [36]

    Philipp Skavantzos and Sebastian Link. 2025. Third and Boyce-Codd normal form for property graphs.VLDB J.34, 2 (2025), 23

    2025

  2. [1]

    1995.Foundations of Databases

    Serge Abiteboul, Richard Hull, and Victor Vianu. 1995.Foundations of Databases. Addison-Wesley

    1995

  3. [2]

    Shqiponja Ahmetaj, Iovka Boneva, Jan Hidders, Katja Hose, Maxime Jakubowski, José Emilio Labra Gayo, Wim Martens, Fabio Mogavero, Filip Murlak, Cem Okul- mus, Axel Polleres, Ognjen Savkovic, Mantas Simkus, and Dominik Tomaszuk

  4. [3]

    Renzo Angles, Angela Bonifati, Stefania Dumbrava, George Fletcher, Alastair Green, Jan Hidders, Bei Li, Leonid Libkin, Victor Marsault, Wim Martens, Filip Murlak, Stefan Plantikow, Ognjen Savkovic, Michael Schmidt, Juan Sequeda, Slawek Staworko, Dominik Tomaszuk, Hannes Voigt, Domagoj Vrgoc, Mingxi Wu, and Dusan Zivkovic. 2023. PG-Schema: Schemas for Prop...

    2023

  5. [4]

    Hare, Jan Hidders, Victor E

    Renzo Angles, Angela Bonifati, Stefania Dumbrava, George Fletcher, Keith W. Hare, Jan Hidders, Victor E. Lee, Bei Li, Leonid Libkin, Wim Martens, Filip Murlak, Josh Perryman, Ognjen Savkovic, Michael Schmidt, Juan F. Sequeda, Slawek Staworko, and Dominik Tomaszuk. 2021. PG-Keys: Keys for Property Graphs. InSIGMOD Conference. ACM, 2423–2436

    2021

  6. [5]

    William Ward Armstrong. 1974. Dependency Structures of Data Base Relation- ships. InIFIP Congress. North-Holland, 580–583

    1974

  7. [6]

    2016.Data and Information Quality - Dimensions, Principles and Techniques

    Carlo Batini and Monica Scannapieco. 2016.Data and Information Quality - Dimensions, Principles and Techniques. Springer

    2016

  8. [7]

    Angela Bonifati. 2025. Versatile Property Graph Transformations.Proc. VLDB Endow.18, 12 (2025), 5516–5526

    2025

Show all 41 references
  1. [8]

    Angela Bonifati, George H. L. Fletcher, Hannes Voigt, and Nikolay Yakovets. 2018.Querying Graphs. Morgan & Claypool Publishers

    2018

  2. [9]

    Antoon Bronselaer. 2021. Data Quality Management: An Overview of Methods and Challenges. InFQAS (Lecture Notes in Computer Science, Vol. 12871). Springer, 127–141

    2021

  3. [10]

    E. F. Codd. 1970. A Relational Model of Data for Large Shared Data Banks. Commun. ACM13, 6 (1970), 377–387

    1970

  4. [11]

    E. F. Codd. 1971. Further Normalization of the Data Base Relational Model. Research Report / RJ / IBM / San Jose, CaliforniaRJ909 (1971)

    1971

  5. [12]

    E. F. Codd. 1974. Recent Investigations in Relational Data Base Systems. InIFIP Congress. North-Holland, 1017–1021

    1974

  6. [13]

    Claude Delobel and Richard G. Casey. 1973. Decomposition of a Data Base and the Theory of Boolean Switching Functions.IBM J. Res. Dev.17, 5 (1973), 374–386

    1973

  7. [14]

    Lisa Ehrlinger and Wolfram Wöß. 2018. A Novel Data Quality Metric for Mini- mality. InQUAT@WISE (Lecture Notes in Computer Science, Vol. 11235). Springer, 1–15

    2018

  8. [15]

    Nadime Francis, Amélie Gheerbrant, Paolo Guagliardo, Leonid Libkin, Victor Marsault, Wim Martens, Filip Murlak, Liat Peterfreund, Alexandra Rogova, and Domagoj Vrgoc. 2023. GPC: A Pattern Calculus for Property Graphs. InPODS. ACM, 241–250

    2023

  9. [16]

    Nadime Francis, Amélie Gheerbrant, Paolo Guagliardo, Leonid Libkin, Victor Marsault, Wim Martens, Filip Murlak, Liat Peterfreund, Alexandra Rogova, and Domagoj Vrgoc. 2023. A Researcher’s Digest of GQL (Invited Talk). InICDT (LIPIcs, Vol. 255). Schloss Dagstuhl - Leibniz-Zentr...

    2023

  10. [17]

    Jelle Hellings, Marc Gyssens, Jan Paredaens, and Yuqing Wu. 2014. Implication and Axiomatization of Functional Constraints on Patterns with an Application to the RDF Data Model. InFoIKS (Lecture Notes in Computer Science, Vol. 8367). Springer, 250–269

    2014

  11. [18]

    2018.Datenbanken - Konzepte und Sprachen, 6

    Andreas Heuer, Gunter Saake, and Kai-Uwe Sattler. 2018.Datenbanken - Konzepte und Sprachen, 6. Auflage. MITP

    2018

  12. [19]

    Rashid, Anisa Rula, Lukas Schmelzeisen, Juan F

    Aidan Hogan, Eva Blomqvist, Michael Cochez, Claudia d’Amato, Gerard de Melo, Claudio Gutierrez, Sabrina Kirrane, José Emilio Labra Gayo, Roberto Nav- igli, Sebastian Neumaier, Axel-Cyrille Ngonga Ngomo, Axel Polleres, Sabbir M. Rashid, Anisa Rula, Lukas Schmelzeisen, Juan F. S...

    2022

  13. [20]

    ISO/IEC 39075:2024 - Information technology — Database languages — GQL

    ISO GQL. ISO/IEC 39075:2024 - Information technology — Database languages — GQL. https://www.iso.org/standard/76120.html

    2024

  14. [21]

    Ernests Lavrinovics, Russa Biswas, Johannes Bjerva, and Katja Hose. 2025. Knowl- edge Graphs, Large Language Models, and Hallucinations: An NLP Perspective. J. Web Semant.85 (2025), 100844

    2025

  15. [22]

    2007.Informationsintegration - Architekturen und Methoden zur Integration verteilter und heterogener Datenquellen

    Ulf Leser and Felix Naumann. 2007.Informationsintegration - Architekturen und Methoden zur Integration verteilter und heterogener Datenquellen. dpunkt.verlag

    2007

  16. [23]

    Junhong Lin, Xiaojie Guo, Yada Zhu, Samuel Mitchell, Erik Altman, and Julian Shun. 2024. FraudGT: A Simple, Effective, and Efficient Graph Transformer for Financial Fraud Detection. InICAIF. ACM, 292–300

    2024

  17. [24]

    Maude Manouvrier and Khalid Belhajjame. 2026. Graph functional dependencies: Analysis and translation to PG-schema.Inf. Syst.136 (2026), 102633

    2026

  18. [25]

    Graph data model

    Memgraph. Graph data model. https://memgraph.com/docs/data-modeling/ graph-data-model

  19. [26]

    Graph database concepts

    Neo4j. Graph database concepts. https://neo4j.com/docs/getting-started/ appendix/graphdb-concepts/

  20. [27]

    2026.Northwind Graph Example

    Neo4j. 2026.Northwind Graph Example. https://github.com/neo4j-graph- examples/northwind

    2026

  21. [28]

    Offshore Leaks Database

    International Consortium of Investigative Journalists. Offshore Leaks Database. https://github.com/ICIJ/offshoreleaks-data-packages

  22. [29]

    1989.The Structure of the Relational Database Model

    Jan Paredaens, Paul De Bra, Marc Gyssens, and Dirk Van Gucht. 1989.The Structure of the Relational Database Model. EATCS Monographs on Theoretical Computer Science, Vol. 17. Springer

    1989

  23. [30]

    Terence Parr. ANTLR. https://www.antlr.org

  24. [31]

    Kashif Rabbani, Matteo Lissandrini, Angela Bonifati, and Katja Hose. 2024. Trans- forming RDF Graphs to Property Graphs using Standardized Schemas.Proc. ACM Manag. Data2, 6 (2024), 242:1–242:25

    2024

  25. [32]

    Aref, Marcelo Arenas, Maciej Besta, Peter A

    Sherif Sakr, Angela Bonifati, Hannes Voigt, Alexandru Iosup, Khaled Ammar, Renzo Angles, Walid G. Aref, Marcelo Arenas, Maciej Besta, Peter A. Boncz, Johannes Schrott, Maxime Jakubowski, and Katja Hose Khuzaima Daudjee, Emanuele Della Valle, Stefania Dumbrava, Olaf Hartig, Ber...

    2021

  26. [33]

    2026.London Public Transport

    Johannes Schrott. 2026.London Public Transport. doi:10.5281/zenodo.18479731

    2026 doi

  27. [34]

    2026.Train Services

    Johannes Schrott. 2026.Train Services. doi:10.5281/zenodo.18478421

    2026 doi

  28. [35]

    Philipp Skavantzos and Sebastian Link. 2023. Normalizing Property Graphs. Proc. VLDB Endow.16, 11 (2023), 3031–3043

    2023

  29. [37]

    Philipp Skavantzos, Kaiqi Zhao, and Sebastian Link. 2021. Uniqueness Constraints on Property Graphs. InCAiSE (Lecture Notes in Computer Science, Vol. 12751). Springer, 280–295

    2021

  30. [38]

    2000.Entity-relationship modeling - foundations of database technology

    Bernhard Thalheim. 2000.Entity-relationship modeling - foundations of database technology. Springer

    2000

  31. [39]

    Bernhard Thalheim. 2020. Schema Optimisation Instead of (Local) Normalisation. InFoIKS (Lecture Notes in Computer Science, Vol. 12012). Springer, 281–300

    2020

  32. [40]

    Piccadilly Circus

    Domagoj Vrgoc, Carlos Rojas, Renzo Angles, Marcelo Arenas, Diego Arroyuelo, Carlos Buil-Aranda, Aidan Hogan, Gonzalo Navarro, Cristian Riveros, and Juan Romero. 2023. MillenniumDB: An Open-Source Graph Database System.Data Intell.5, 3 (2023), 560–610. A Graph-Native Approach t...

    2023

  33. [2025]

    Common Foundations for SHACL, ShEx, and PG-Schema. InWWW. ACM, 8–21

Pith tools

Reviewed August 2, 2026 · model on record in the stance chip above.