{"id":"b6d578e8-ea76-413e-819a-c88ae33b39cf","arxiv_id":"2508.03978","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"high","formal_verification":"none","parameter_count":0,"one_line_summary":"A cross-paradigm source-to-source compiler for recursive queries, using PGIR, DLIR, and SQIR intermediate representations, with static analyses and optimizations, but only preliminary evaluation and no formal proofs.","lead":"Raqlet is a compiler framework that translates recursive queries between Datalog, Cypher, and SQL by passing them through three intermediate representations. It aims to make recursive queries portable across database paradigms and to serve as a formal reference for query language standards.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Paper itself removes ORDER BY/LIMIT and switches to DISTINCT to get equivalence, so the semantic-preservation/golden-reference claim fails for exactly the excluded features.","rationale":"I agree with the reader's weakest assumption. The architecture and running example are clearly presented, and the authors are honest about the feature removal, but that honesty makes the gap explicit rather than hypothetical: a compiler that drops ORDER BY/LIMIT and imposes DISTINCT cannot support the abstract's claim of portability and formal reasoning for recursive queries across full dialects. The experimental section evaluates only two queries, both on the fragment, and no artifact or formal proof is provided. Section 6 explicitly defers the semantic formalization to future work. Therefore the central claim is not established, and the appropriate verdict remains REJECT.","tokens_in":11289,"tokens_out":3890,"duration_ms":47118,"concrete_test":"Run an LDBC read query that actually contains ORDER BY ... LIMIT (e.g., Short Query 3 or 4) through Raqlet unmodified, executing the original on Neo4j and the generated query on DuckDB/Soufflé over the same SF10 graph. If the generated result relation is not identical to the Neo4j result (or Raqlet refuses to translate the query), the translation is directly falsified as semantics-preserving.","verdict_should_be":"REJECT","load_bearing_attack":"The load-bearing step is the claim that compilation to DLIR preserves input-query semantics and that DLIR can serve as a golden reference for SQL/PGQ and GQL/Cypher. The paper states in Section 3 that, to achieve semantic equivalence, 'we use RETURN DISTINCT instead and remove ORDER BY and LIMIT clauses in input Cypher queries.' That is an explicit semantic alteration: removing ORDER BY/LIMIT changes which tuples are returned (and in what order) whenever the original query limits results, and DISTINCT collapses duplicate rows. DLIR is defined with Datalog set semantics, so no machinery is presented for ordered or bag semantics, nor for the aggregation and shortest-path constructs that PGIR claims to support. Section 6 only says formalization is planned ('we plan to formalize DLIR semantics, Raqlet's translation pipeline...'); no proof is supplied. Thus the central condition—faithful representation of all target-language features—is not merely unproven; the paper describes a translation that knowingly changes it.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"Raqlet is a source-to-source compilation framework for recursive queries. It translates Cypher or SQL/PGQ into a property-graph IR (PGIR), then into a Datalog-inspired IR (DLIR), and finally into Datalog or recursive SQL (SQIR). The paper describes the architecture, several planned static analyses (linearity, mutual recursion, monotonicity, termination), a set of planned optimizations (inlining, dead-rule elimination, magic sets), and a preliminary experiment on two LDBC queries. The stated goals are cross-paradigm portability, static reasoning, and a formally grounded 'golden reference' semantics for SQL/PGQ and GQL/Cypher. The paper presents a running example, but the formal semantics and machine-checked proofs are explicitly left to future work.","tokens_in":11567,"tokens_out":4750,"duration_ms":58685,"significance":"If fully realized, the proposed framework would be a valuable contribution to the fragmented recursive-query landscape: it addresses a real interoperability problem, and the choice of Datalog-style fixpoint semantics as a common core is well motivated. The paper is clearly structured, and the running example helps convey the translation pipeline. However, the manuscript's central claims currently outrun its evidence. The semantic-preservation claim is undermined by an explicit removal of ORDER BY and LIMIT, the formal-semantics section describes only plans, and the experimental evaluation is too small to support the performance statements. The paper is better read as a vision or system-position statement than as a validation of the claimed cross-paradigm equivalence.","major_comments":[{"comment":"The paper states: 'Given that most deductive databases utilize set semantics and lack certain features such as ordering and limiting the results, to achieve semantic equivalence in translated queries across different backends, we use RETURN DISTINCT instead and remove ORDER BY and LIMIT clauses in input Cypher queries.' This is an explicit admission that the translation is not semantics-preserving for the full input language: removing ORDER BY/LIMIT changes the result set whenever the original query truncates or orders its output, and RETURN DISTINCT collapses duplicates. Since the abstract and Section 6 claim a 'shared semantic basis' and 'golden reference implementation', this is not a local limitation. No formal statement is given of the fragment for which equivalence does hold, and the example translations do not establish equivalence even for that fragment.","section":"Section 3 (System Overview)"},{"comment":"The formal-semantics section says 'we plan to formalize DLIR semantics, Raqlet's translation pipeline, and DLIR optimizations using proof assistants such as Rocq or Lean.' Thus no formal semantics is actually supplied in this manuscript. The statement that 'DLIR serves as a golden reference implementation for the SQL:2023 and GQL standard' is an intention, not a result. Because the PGIR-to-DLIR and DLIR-to-SQL translations are only demonstrated through examples, a reader cannot verify the correctness of the pipeline for any nontrivial fragment.","section":"Section 6 (Towards Formal Semantics)"},{"comment":"The evaluation contains two LDBC queries at SF10, with a single timing per cell, no error bars, no repeated runs, no data-size sweep, and no optimized Neo4j baseline. The text concludes that 'in most cases, translated Datalog and SQL queries have lower execution times compared to the original Cypher query.' The evidence is insufficient to support even this modest performance claim. More importantly, the experiment does not check that the translated queries produce the same results as the original Cypher queries, so it does not compensate for the missing correctness argument.","section":"Table 1 / Section 5 (Preliminary Experimental Results)"},{"comment":"The running example is a non-recursive MATCH ... RETURN DISTINCT query. The paper's central topic is recursive query compilation, yet no recursive translation is shown anywhere in the pipeline. The recursion-related discussion in Section 4 is conceptual and references known techniques rather than demonstrating Raqlet's handling of recursive PGIR or DLIR constructs. This leaves the core claimed capability—compiling recursive queries across paradigms—unsubstantiated by any concrete example or translation rule.","section":"Section 3 (Running Example)"}],"minor_comments":[{"comment":"'Soufflè' should be 'Soufflé' for consistency with the rest of the paper.","section":"Figure 3(d)"},{"comment":"There is a grammatical error: 'Raqlet’s allows for generating' should be 'Raqlet allows for generating'.","section":"Section 5 (Code Generation)"},{"comment":"'fix-point logic' should be 'fixed-point logic' or 'fixpoint logic'.","section":"Section 6"},{"comment":"Please clarify whether the reported times are single runs, medians, or means, and define what the checkmark/cross in the 'Optimized' column means precisely.","section":"Table 1"},{"comment":"The PG-Schema syntax shown is nonstandard (e.g., colons and arrow notation). A reference to the exact PG-Schema grammar or a note that this is a simplified notation would help reproducibility.","section":"Figure 2"}],"recommendation":"reject","confidential_remarks":"This is an early vision/system description. The central claims of semantic preservation and golden-reference status are not substantiated, and the explicit removal of ORDER BY/LIMIT is not a local fixable issue: it changes the very claim being made. The paper could become suitable for a workshop venue or a future submission after a substantial revision that (a) restricts the claims to a precisely defined set-semantics fragment, (b) provides formal translation rules and at least a proof sketch of equivalence for that fragment, and (c) replaces the anecdotal experiment with a rigorous benchmark. As submitted, I cannot recommend acceptance for a journal."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Raqlet is worth reading for anyone working on recursive query translation, but the headline claims outrun the evidence. What's genuinely new: a three-IR pipeline (PGIR→DLIR→SQIR) that puts a Datalog-like IR at the center and applies standard static analyses (linearity, mutual recursion, monotonicity) once, across source languages. The running example is clear, and the integration of existing ideas—magic sets, inlining, dead-rule elimination—is sensible and well-explained. The paper reads like an honest engineering report at the architecture level.\n\nThe soft spots are in the semantics and the evaluation. The paper says in Section 3 that to get 'semantic equivalence' it removes ORDER BY and LIMIT and uses RETURN DISTINCT. That means the translation does not preserve the input query's semantics for any query that uses those features—which includes a large fraction of real Cypher queries. The golden-reference claim in Section 6 cannot stand on that basis. Section 6 also says formalization is 'planned,' so there is no proof or machine-checked development in hand. That is fine for a position paper, but the paper currently asserts semantic preservation as a fact rather than a goal.\n\nThe experiments are preliminary in the honest sense: two LDBC queries, one data size, no error bars, no optimized Neo4j baseline, and no check that translated queries return the same results as the original. The performance numbers are suggestive but not decisive.\n\nNone of this kills the core idea. A cross-paradigm IR with a Datalog core is a reasonable design, and the paper is upfront about its limitations—it calls them 'preliminary results' and says a full evaluation is future work. The main fix is to scope the claims: say the framework is semantics-preserving for the fragment without ORDER BY/LIMIT (or with a defined transformation for them), and treat the formalization as a roadmap, not a result.\n\nI'd send this to a serious referee. The architecture is novel enough and the problem is real enough to warrant a careful review that pushes the authors to either restrict their claims, add correctness tests, or provide the formal semantics they promise. I wouldn't cite it in its current form, but I'd bring it to a reading group to discuss where the semantic boundary should be drawn.","headline":"Solid compiler architecture for recursive queries, but the paper's semantic-preservation and golden-reference claims are undone by its own removal of ORDER BY/LIMIT and lack of any correctness evidence.","tokens_in":12003,"tokens_out":2327,"would_cite":false,"duration_ms":28596,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Raqlet claims that recursive queries in Cypher, SQL/PGQ, and Datalog can all be lowered into a shared Datalog-inspired representation, giving one formal semantics and one optimizer for every paradigm.","keywords":["recursive queries","cross-paradigm compilation","Datalog","Cypher","SQL/PGQ","GQL","intermediate representation","query semantics"],"falsifier":"Compile a Cypher query that contains ORDER BY and LIMIT and compare the result set and order with a direct execution on the original graph database; any translation that drops these clauses will produce different observable output, showing that semantic preservation fails for that fragment. A broader suite of recursive queries with bag semantics and nested aggregation run through Raqlet and compared against reference engines would also bound the claim.","tokens_in":11201,"feed_emoji":"🔁","tokens_out":5310,"duration_ms":59005,"temperature":0.7,"pith_summary":"The paper proposes Raqlet, a source-to-source compiler that translates recursive queries among graph query languages (Cypher, SQL/PGQ, GQL), recursive SQL, and Datalog by lowering them all into a shared Datalog-inspired intermediate representation called DLIR. The central claim is that a single semantic core, grounded in the least-fixed-point semantics of stratified Datalog, can serve as a common formal basis for all these paradigms, letting a query written in one language be run on another system and reasoned about statically. If true, this would decouple users from committing to one database paradigm early, enable formal verification of query translations, and give standards bodies a reference implementation for SQL:2023 and GQL. The paper supports the claim by showing translations for a social-network query and reporting preliminary performance numbers where the translated Datalog and SQL versions often run faster than the original graph query.","feed_headline":"One Datalog-style core unifies recursive SQL, Cypher, and GQL","feed_subtitle":"A source-to-source compiler translates Cypher and SQL/PGQ into Datalog-inspired rules, with static analysis and optimization done once.","key_machinery":"DLIR, a Datalog-inspired intermediate representation with stratified negation and aggregation, whose rules are anchored by the least-fixed-point semantics of Datalog. It is the layer where all input languages meet, where static analyses (linearity, mutual recursion, monotonicity, termination) run, and where transformations such as inlining, dead-rule elimination, and magic sets are applied before code generation to SQL, Datalog, or lower-level procedural IRs.","core_discovery":"Raqlet's central discovery is that Datalog's rule-based structure is a sufficient common denominator: graph patterns, filters, projections, and recursive predicates from Cypher and SQL/PGQ can be represented as DLIR rules, then emitted as recursive SQL or Datalog with set semantics. The paper defines three intermediate representations (PGIR, DLIR, SQIR) in a pipeline and concentrates static analysis and optimization at the DLIR layer, so analyses like linearity, mutual recursion, monotonicity, and termination are done once for all input languages. It also claims DLIR inherits well-defined formal semantics from stratified Datalog, making it a candidate golden reference implementation for grap","pith_inferences":["If DLIR semantics are made machine-checked, the same core could serve as a differential-testing oracle for commercial graph and SQL systems, not just a compiler.","The removal of ORDER BY and LIMIT suggests the unification is cleanest for set-oriented, order-insensitive queries; order- and bag-sensitive features likely need a separate semantics for each target, so the golden reference may only cover a fragment of the languages.","The paper's performance results are on two queries; extending to the full set of social-network benchmark queries would likely reveal where specific backends dominate, turning the framework into a benchmark harness.","Cross-paradigm translation may also enable mixing: a query written in Datalog could exploit graph-specific path indexing, or a graph query could benefit from relational aggregation optimizations, without rewriting."],"forward_implications":["Users can write a recursive query in a graph language like Cypher and execute it on relational or Datalog engines after automatic translation, avoiding manual porting.","Static analyses at the DLIR layer can reject queries a backend does not support (e.g., non-linear or mutually recursive queries on engines that only allow linear recursion) before execution.","DLIR's formal Datalog semantics give a golden reference point for judging SQL:2023 and GQL implementations, exposed when systems disagree.","Optimizations such as magic-set rewriting and rule inlining apply uniformly to queries from any source language, with preliminary experiments showing translated Datalog and SQL versions often outperform the original graph query.","Layering additional IRs on the backend enables eventual low-level code generation from the same semantic core."],"supporting_citations":[{"why":"Defines Cypher, the primary input language whose semantics the pipeline must preserve.","marker":"[17]"},{"why":"Provides the pattern calculus GPC on which PGIR's pattern constructs are based.","marker":"[16]"},{"why":"Specifies SQL/PGQ, one of the standard query languages Raqlet aims to compile from and translate to.","marker":"[24]"},{"why":"Defines the GQL standard that Raqlet targets as input.","marker":"[25]"},{"why":"Survey of GQL used to frame the need for a shared semantic core.","marker":"[33]"},{"why":"Documents recursive CTE limitations (no non-linear or mutual recursion), motivating static-analysis rejection at DLIR.","marker":"[23]"},{"why":"Establishes inconsistencies and non-termination risks in recursive query semantics that a golden reference should resolve.","marker":"[21]"},{"why":"Critiques modern SQL inconsistencies, supporting the claim that a formal reference implementation is needed.","marker":"[31]"},{"why":"Magic-set transformation, the main recursive optimization applied at the DLIR layer.","marker":"[7]"},{"why":"Empirical comparison showing Datalog engines outperform SQL and graph systems on recursive queries, motivating cross-paradigm translation.","marker":"[10]"}],"fun_headline_variants":["Raqlet: one Datalog core for recursive SQL, Cypher, GQL","Cross-paradigm queries: one Datalog-style IR does it all","Raqlet converts Cypher, SQL, and GQL to one Datalog core","Datalog as the universal IR for recursive queries across dialects","Raqlet: compile any recursive query language to Datalog rules"],"cache_read_input_tokens":2816,"weakest_assumption_plain":"The load-bearing premise is that Datalog-style set semantics over relations can faithfully capture Cypher and SQL/PGQ query semantics, including ordering, limits, and aggregation; the paper does not prove this and instead removes ORDER BY and LIMIT and uses DISTINCT in its example.","fun_headline_variants_meta":{"raw":{"variants":["Raqlet: one Datalog core for recursive SQL, Cypher, GQL","Cross-paradigm queries: one Datalog-style IR does it all","Raqlet converts Cypher, SQL, and GQL to one Datalog core","Datalog as the universal IR for recursive queries across dialects","Raqlet: compile any recursive query language to Datalog rules"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000697,"raw_usage":{"total_tokens":2984,"prompt_tokens":740,"completion_tokens":2244,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":484,"completion_tokens_details":{"reasoning_tokens":2146}},"tokens_in":484,"tokens_out":2244,"duration_ms":16788,"temperature":1.0,"reasoning_tokens":2146,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T00:57:43.279191+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compile a Cypher query that contains ORDER BY and LIMIT and compare the result set and order with a direct execution on the original graph database; any translation that drops these clauses will produce different observable output, showing that semantic preservation fails for that fragment. A broader suite of recursive queries with bag semantics and nested aggregation run through Raqlet and compared against reference engines would also bound the claim.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Provides the pattern calculus GPC on which PGIR's pattern constructs are based."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Specifies SQL/PGQ, one of the standard query languages Raqlet aims to compile from and translate to."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Defines the GQL standard that Raqlet targets as input."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Survey of GQL used to frame the need for a shared semantic core."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Documents recursive CTE limitations (no non-linear or mutual recursion), motivating static-analysis rejection at DLIR."},{"cited_title":"Language-Integrated Recursive Queries (Full Version)","cited_arxiv_id":"2504.02443","evidence_quote":"Establishes inconsistencies and non-termination risks in recursive query semantics that a golden reference should resolve."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Critiques modern SQL inconsistencies, supporting the claim that a formal reference implementation is needed."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Magic-set transformation, the main recursive optimization applied at the DLIR layer."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Empirical comparison showing Datalog engines outperform SQL and graph systems on recursive queries, motivating cross-paradigm translation."}],"review_version":1}