{"id":"b0cab1c4-ec89-420f-8bd7-6a0d2e2c8fa0","arxiv_id":"2411.09999","paper_version":1,"verdict":"UNVERDICTED","confidence":"HIGH","novelty_score":0.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"A tutorial and survey of graph databases and graph algorithms that compiles existing material but contains several incorrect code outputs.","lead":"This paper is a tutorial and survey of graph databases, covering graph theory, algorithms, and tools like NetworkX and Neo4j. It contains no new research results, and several worked examples produce incorrect answers.","discovery_kind":"review","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The tutorial's central claim of being a reliable guide is falsified by multiple non-reproducible code outputs, including connected components, closeness centrality, and PageRank.","rationale":"The reader's weakest assumption correctly identified the printed code outputs as the load-bearing element: a tutorial's value depends on readers being able to trust its examples. My independent check confirms the concern and strengthens it with additional evidence. Listing 23 misreports connected components on a two-component graph; Listing 40 assigns impossible closeness values to the nodes of a symmetric 5-cycle; Listing 41's PageRank values do not satisfy the paper's own recurrence; Listing 31's difference-graph output drops a node that must survive. These are not subtle numerical disagreements or matters of opinion; each is a deterministic, checkable computation. Because the paper is a tutorial and survey rather than a novel research contribution, the reader's UNVERDICTED classification remains appropriate, but the errors confirm that the current draft is not reliable as a comprehensive teaching reference. The proposed test settles the concern directly by executing the exact listings in a standard environment; no external datasets or subjective judgment are needed.","tokens_in":34401,"tokens_out":3636,"duration_ms":34339,"concrete_test":"Run Listings 23, 31, 40, and 41 in a clean Python environment with the NetworkX version cited in the paper and compare each printed output to the paper's 'Expected Output' blocks. Also independently solve the PageRank recurrence from Section VI.C for Listing 41's directed graph. If any output differs from the paper's claim, the tutorial's central reliability claim is falsified.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's central claim is that it is a comprehensive and reliable tutorial on graph databases. That claim fails at the worked examples: the printed outputs are not reproducible and, in several cases, contradict the paper's own definitions. Listing 23 builds nx.Graph([(1, 2), (2, 3), (4, 5)]) and claims 'Connected Components: [1, 2, 3, 4, 5]', but the graph has two connected components, {1, 2, 3} and {4, 5}, and Figure 8 on the same page shows both. Listing 40 computes closeness centrality on a 5-cycle whose nodes are all symmetric; the actual NetworkX output is 0.667 for every node, not 0.67, 0.80, 1.00, 0.80, 0.67, and a value of 1.00 is impossible in this graph. Listing 41's PageRank scores [0.29, 0.34, 0.26, 0.11] do not solve the paper's own PageRank equation for the displayed directed graph; independent iteration gives approximately [0.174, 0.333, 0.320, 0.174]. Listing 31's nx.difference output also omits node 2, which must remain in the difference graph because it is present in G1 and not removed by G2. A tutorial whose sample outputs are wrong cannot serve as a reliable pedagogical reference, which is the central claim of the paper. This is a correctness defect in the artifact's core deliverable, not merely a stylistic inconsistency.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper is a tutorial and survey on graph databases, covering introductory graph theory, graph database systems (Neo4j, Amazon Neptune, ArangoDB), practical operations in NetworkX and Neo4j/Cypher, visualization techniques, advanced algorithms such as Dijkstra, centrality measures, PageRank, community detection, large-graph optimization, and applications. The stated goal is to serve as a comprehensive, practical guide for researchers and practitioners entering the field.","tokens_in":34784,"tokens_out":7035,"duration_ms":67212,"significance":"If accurate, the tutorial would be a useful one-stop pedagogical resource: it brings together a broad set of topics, provides concrete code listings in two widely used systems, and grounds the discussion in a substantial bibliography. The paper also makes machine-checkable claims through its printed outputs, which is a strength because the correctness of a tutorial can be verified directly. However, the tutorial's central value depends entirely on the reliability of these worked examples, and several are demonstrably wrong. The paper therefore cannot currently serve as the dependable guide it claims to be, although the identified errors are local and correctable.","major_comments":[{"comment":"The printed 'Connected Components: [1, 2, 3, 4, 5]' is incorrect for the graph G = nx.Graph([(1, 2), (2, 3), (4, 5)]) defined in the listing. That graph has two disconnected components, {1, 2, 3} and {4, 5}, and Figure 8 on the same page states exactly this. The output should be a list of two sets (e.g., [{1, 2, 3}, {4, 5}]). Since the example is meant to teach connected components, this error is load-bearing for the tutorial's reliability.","section":"Section III.C, Listing 23"},{"comment":"The claimed closeness centrality output for a five-node cycle graph, '1: 0.67, 2: 0.80, 3: 1.00, 4: 0.80, 5: 0.67', cannot be correct. All nodes of a cycle C5 are symmetric, so their closeness centrality values must be equal; moreover, a value of 1.00 would require the node to be adjacent to all other four nodes, which is not true. NetworkX returns 0.667 for every node. This incorrect output undermines the centrality example.","section":"Section VI.B.2, Listing 40"},{"comment":"The reported PageRank scores [0.29, 0.34, 0.26, 0.11] do not satisfy the PageRank formula stated in the same section. For node 1, the equation gives PR(1) = 0.15/4 + 0.85 * PR(3)/2; with PR(3) = 0.26 this is 0.148, not 0.29. Solving the system for the displayed directed graph yields approximately [0.174, 0.333, 0.320, 0.174], which is also what NetworkX computes. The example thus contradicts the paper's own definition and the actual library output.","section":"Section VI.C.1, Listing 41"},{"comment":"The expected output for nx.difference omits node 2 from the difference graph, but node 2 is present in G1 and is not deleted by the difference operation, so it must appear in the node list. The listed edges [(1, 2), (3, 4)] are also inconsistent with the listed nodes, since edge (1, 2) requires node 2. The correct output should include nodes [1, 2, 3, 4] in some order.","section":"Section IV.C.3, Listing 31"}],"minor_comments":[{"comment":"The heading before Listing 21 says 'Retrieving Edges using Neo4j from Python', but the listing actually computes Dijkstra's shortest path; the heading should be corrected.","section":"Section III.B.2, Listing 21"},{"comment":"There are numerous typographical errors, e.g., 'grpah' and 'ususally' in Section I.A.1; the text needs a careful proofreading pass.","section":"Section I.A"},{"comment":"The printed output for node and edge attributes is missing the surrounding braces of the dictionary, e.g., 'The attributes for the node Bob are: ’age’: 25...' should be presented as a dictionary literal such as {'age': 25, 'city': 'Los Angeles'}.","section":"Listings 7 and 9"},{"comment":"Several listings have 'Output message' or 'Expected Output' lines placed inside the code listings without clear visual separation, making it easy for readers to mistake printed output for code.","section":"Throughout"},{"comment":"Reference [2] appears to be unrelated to the topic discussed at the point where it is cited; please verify the relevance of all references.","section":"References"}],"recommendation":"major_revision","confidential_remarks":"The paper is a tutorial/survey whose value is pedagogical. The four incorrect worked examples identified above are fixable by re-running the code and replacing the printed outputs, but they currently undermine the central claim of being a reliable guide. In addition, the manuscript has numerous small formatting and typographical issues that suggest it needs careful editing before resubmission. I also note that references [9] and [68] are self-citations of one of the authors; they are not a problem in themselves, but the authors may wish to mark them as such for transparency."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know. First, this is a survey/tutorial with no new research content: it rehashes standard graph theory, vendor docs for Neo4j/Neptune/ArangoDB, and textbook algorithms. Second, its central value proposition—accurate worked examples—fails: several printed outputs are wrong, and they contradict the paper's own definitions.\n\nWhat it does well: it gathers a wide range of topics in one place, with 144 references covering graph theory, NetworkX, Cypher, visualization, community detection, and GNNs. The organization is sensible for a beginner looking for a starting point. Most of the conceptual definitions are correct.\n\nWhere it breaks down: the code outputs were clearly not run. Listing 23 builds a graph with two connected components and prints [1,2,3,4,5]. Listing 40 gives closeness centrality 1.00 to a node in a 5-cycle; in an undirected cycle all nodes are symmetric and NetworkX returns 0.667 for every node. Listing 41's PageRank scores do not satisfy the paper's own PageRank equation. Listing 31's difference graph omits node 2, which must remain. These are not cosmetic; they are the tutorial's core deliverable. There are smaller slips too, like Listing 21 labeled 'Retrieving Edges using Neo4j' above Dijkstra code in NetworkX.\n\nWho this is for: absolute beginners, who are precisely the readers least able to detect wrong outputs. I would not cite it in its current form. As a peer review matter, I would not send it out as is; it needs a full pass where every listing is executed and corrected. If that is done, a revised version might be a useful educational artifact. As it stands, the paper does not meet the standard for a reliable tutorial.","headline":"Tutorial with no new research content whose worked examples are several demonstrably wrong; usable only after every listing is run and corrected.","tokens_in":35201,"tokens_out":3311,"would_cite":false,"duration_ms":35321,"reading_group":"no","serious_thinker":"yes","would_accept_peer_review":false},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This tutorial claims that graph databases are specialized systems for complex, interconnected data and offers a comprehensive guide from graph theory through practical implementation in NetworkX and Neo4j.","keywords":["graph databases","Neo4j","NetworkX","graph theory","Cypher queries","community detection","centrality measures","graph visualization"],"falsifier":"Run the NetworkX code of Listing 23 on the graph with edges (1,2), (2,3), (4,5) and check that connected_components returns two sets, {1,2,3} and {4,5}, not the single list printed in the paper; likewise compute closeness centrality for the five-node cycle in Listing 40 and confirm that node 3's value is not 1.00. Either mismatch would refute the tutorial's claim that its expected outputs are trustworthy.","tokens_in":34162,"feed_emoji":"🕸️","tokens_out":3970,"duration_ms":36385,"temperature":0.7,"pith_summary":"The paper sets out to establish that graph databases have emerged as specialized systems for handling complex, interconnected data, and that a single tutorial can guide a reader from the basics of graph theory through practical database operations. It positions graph databases against relational databases, arguing that the node-and-edge model removes costly joins and naturally supports traversal-heavy analytics. The bulk of the paper is a hands-on walkthrough: creating and visualizing graphs in NetworkX and Neo4j, running Dijkstra's shortest path, computing centrality measures and PageRank, detecting communities with Louvain, and building small graph-based applications. If the tutorial's instructions and outputs are accurate, it gives a new entrant a usable path into the field.","feed_headline":"Graph databases: one tutorial from theory to code","feed_subtitle":"Covers graph theory, shortest paths, centrality, PageRank, and hands-on Neo4j and NetworkX examples.","key_machinery":"The teaching engine is the property graph model: nodes (entities) and edges (relationships) that hold key-value attributes, queried either imperatively in Python via NetworkX or declaratively via Cypher in Neo4j. This model carries the argument because every major concept, including degree, path length, connected components, centrality, PageRank, and community detection, is defined on it and then demonstrated as a short code listing.","core_discovery":"The central claim the authors are establishing is that the property graph model, where nodes and edges carry attributes, provides a unified and pedagogically tractable way to represent and query interconnected data, and that mainstream tools (NetworkX for programming, Neo4j with Cypher for a database) cover the full workflow. The paper's own contribution is the synthesis: a single narrative that goes from graph definitions, through algorithms such as Dijkstra and centrality measures, to implementation and deployment in real-world applications.","pith_inferences":["The tutorial could be used as a course module outline, with each section mapping to a lab exercise.","The breadth of coverage suggests graph database education is converging on a standard toolchain of Python and Neo4j, which shapes how practitioners are trained.","Readers following the code listings should verify outputs against the actual libraries, since a tutorial of this kind is only as reliable as its examples."],"forward_implications":["A reader who follows the tutorial can construct and query a property graph in both NetworkX and Neo4j.","The comparison to relational databases positions graph databases as the preferred choice when multi-level relationship traversal dominates the workload.","The algorithm coverage allows a newcomer to compute shortest paths, centrality, and community structure with standard libraries.","The case studies (social network, recommender, fraud detection) show the same graph operations transferring across domains."],"supporting_citations":[{"why":"Supplies the taxonomy and system-design analysis that grounds the claim that graph databases are specialized for interconnected data.","marker":"[16]"},{"why":"Provides the overview of Neo4j's property graph model and its advantages, which the tutorial builds on.","marker":"[54]"},{"why":"Supports the description of Neo4j's data handling and Cypher capabilities used throughout the practical sections.","marker":"[105]"},{"why":"Backs the argument that large graphs are ubiquitous and that relational approaches struggle with graph-style queries.","marker":"[109]"},{"why":"Underlies the relational-database comparison by discussing complexity reduction when moving to Neo4j.","marker":"[30]"},{"why":"Supports the treatment of property graph models and Cypher as a mapping from RDF or relational schemas.","marker":"[8]"}],"fun_headline_variants":["From graph theory to Neo4j in one tutorial","Graph databases: the complete practical guide","Master graph data: theory, algorithms, and code","A hands-on tour of graph databases and algorithms","Graph databases demystified: tutorial and survey"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The tutorial's usefulness depends on the correctness of its code listings and printed outputs; if a reader runs the examples and gets different results, the guide fails as a reliable learning resource.","fun_headline_variants_meta":{"raw":{"variants":["From graph theory to Neo4j in one tutorial","Graph databases: the complete practical guide","Master graph data: theory, algorithms, and code","A hands-on tour of graph databases and algorithms","Graph databases demystified: tutorial and survey"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000134,"raw_usage":{"total_tokens":1094,"prompt_tokens":855,"completion_tokens":239,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":471,"completion_tokens_details":{"reasoning_tokens":168}},"tokens_in":471,"tokens_out":239,"duration_ms":3103,"temperature":1.0,"reasoning_tokens":168,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T20:04:06.694674+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the NetworkX code of Listing 23 on the graph with edges (1,2), (2,3), (4,5) and check that connected_components returns two sets, {1,2,3} and {4,5}, not the single list printed in the paper; likewise compute closeness centrality for the five-node cycle in Listing 40 and confirm that node 3's value is not 1.00. Either mismatch would refute the tutorial's claim that its expected outputs are trustworthy.","supporting_citations":[{"cited_title":"Supporting data types in neo4j","cited_arxiv_id":null,"evidence_quote":"Supports the description of Neo4j's data handling and Cypher capabilities used throughout the practical sections."},{"cited_title":"The ubiquity of large graphs and surprising challenges of graph processing: extended survey","cited_arxiv_id":null,"evidence_quote":"Backs the argument that large graphs are ubiquitous and that relational approaches struggle with graph-style queries."}],"review_version":1}