{"id":"72b8f00a-1528-4e13-af15-e19749a0cd1d","arxiv_id":"2608.12272","paper_version":1,"verdict":"UNVERDICTED","confidence":"HIGH","novelty_score":4.0,"correctness_risk":"low","formal_verification":"none","parameter_count":0,"one_line_summary":"A tutorial proposal that introduces a vocabulary for separating relational pattern structure from notation and semantics in query languages.","lead":"This tutorial paper presents a framework and vocabulary for comparing relational query languages by separating notation, semantic conventions, query mappings, and relational pattern structures. It is aimed at researchers and practitioners dealing with machine-generated queries that humans must read and revise.","discovery_kind":"review","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Relational pattern structure is defined only informally; the paper's central classification (e.g., P_e1=P_e2=P_e3=P_e4) rests on unformalized judgments, so the claimed 'precise vocabulary' is not yet substantiated.","rationale":"The reader identified the informal definition of 'relational pattern structure' as the weakest assumption; my analysis reaches the same conclusion. The paper is a tutorial proposal, not a research result with formal claims or experiments. Its central value proposition is pedagogical: introducing a vocabulary to separate relational pattern, notation, semantics, and query mapping. The manuscript gives a clear and coherent set of examples, and the distinction between query mapping and semantic conventions is illustrated convincingly. However, the key notion of relational pattern structure is only described informally, and the paper's own definition of pattern isomorphism is flagged as informal. The specific equivalences asserted (P_e1=P_e2=P_e3=P_e4 and P_egroup distinct) are plausible but not formally derived. This is a genuine limitation for a framework that aims to be a 'precise vocabulary.' Still, because the paper is explicitly a tutorial rather than a research contribution, the informal treatment may be acceptable for its stated purpose. The reader's UNVERDICTED verdict is appropriate: the standard research assessment criteria do not directly apply, and the paper makes no testable claims. My concern does not change that verdict; it only underscores that the framework's precision remains to be established in future work, possibly by formalizing pattern isomorphism in ARC. Therefore, I recommend UNCHANGED.","tokens_in":14188,"tokens_out":4464,"duration_ms":41183,"concrete_test":"Formalize pattern isomorphism within ARC (as referenced in [32]) for the four expressions in Figures 2–3, including explicit dissociation and role alignment. Then mechanically verify whether there exists a shared compatible semantic convention C under which the dissociated denotations of e1, e2, e3, and e4 are equal on every aligned input, and under which e_group differs. In particular, test both set and bag semantics and both empty-aggregate behaviors (NULL vs. 0) to see whether the claimed equivalence classes are stable across all compatible choices. If the formalization shows e1 and e3 are not isomorphic under some admissible C, then the paper's central example and the precision of the vocabulary are undermined.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The framework's core concept, relational pattern structure P_e, is introduced through examples and an informal definition: 'Informally, two expressions are pattern-isomorphic if such a bijective alignment makes their dissociated denotations equal on every aligned dissociated input under every shared compatible choice of semantic conventions C.' No formal definition of 'table-reference role,' 'relational construct,' or 'compatible semantic conventions' is provided. The paper's key assertions about P_e depend on this informal notion. For instance, Section 2 claims P_e1=P_e2=P_e3=P_e4, grouping a SQL scalar subquery (e1), a Soufflé rule (e2/e3), and a correlated SQL subquery (e4) into the 'correlated subcollection summary' pattern, while declaring e_group distinct. These classifications are justified by 'conceptual evaluation strategies' rather than derived from the pattern-isomorphism definition. The definition also quantifies over 'every shared compatible choice of C,' but the paper only demonstrates equality under one convention (C_Soufflé) for e1 and e2; it does not show that the dissociated denotations agree for all compatible choices, especially when set vs. bag semantics or different empty-aggregate behaviors are considered. Thus, the central distinction that the tutorial aims to teach—separating relational pattern from notation and semantics—is not actually pinned down. Since the abstract promises participants 'a precise vocabulary for articulating design trade-offs,' this informality is load-bearing: if the notion cannot be formalized (e.g., within ARC, the paper's own reference representation), the framework's value as a precise analytical tool is unsupported.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"This PVLDB tutorial proposal extends an earlier SIGMOD 2026 tutorial and argues that relational query languages should be compared not only in expressive power but also in which relational structures they make explicit and how well their notation supports reading and revising queries. It develops a vocabulary that separates information need, query mapping, relational pattern structure, relational pattern denotation, and semantic conventions, using Abstract Relational Calculus (ARC) and Relational Diagrams as reference representations. The tutorial is organized around worked examples: a SQL scalar subquery and a Soufflé rule with different empty-aggregate behavior, a grouped SQL query and its Soufflé/correlated-SQL counterparts, and recursive, nested, and beyond-PTIME extensions. The paper claims that expressions e1 through e4 instantiate the same relational pattern structure, while egroup has a different one, and that differences in query results under native semantics are due to semantic conventions, not pattern structure.","tokens_in":14504,"tokens_out":5838,"duration_ms":52629,"significance":"If the proposed vocabulary were made precise, it would address a real gap: most language comparisons focus on logical expressiveness, whereas the paper targets structural explicitness and readability, which are particularly relevant when queries are generated by machines and inspected by humans. The worked examples are internally consistent and accurate: the SQL/Soufflé empty-aggregate difference is described correctly, the query mappings for egroup and e3 coincide on the constrained schema, and the dissociation/substitution equation is true by construction. The paper also gives a useful map of recent relational, graph, and dataframe languages. Its main weakness is that the central concept of relational pattern isomorphism is only informally defined and the claimed equalities are not derived from it. As a tutorial proposal the lack of a full formalization is understandable, but because the paper explicitly promises a 'precise vocabulary,' this gap directly affects the stated deliverable rather than being a minor presentation issue.","major_comments":[{"comment":"The paper's central classification P_e1=P_e2=P_e3=P_e4 is stated on the basis of 'conceptual evaluation strategies' rather than derived from the informal definition of pattern isomorphism. The definition leaves undefined the notions of 'table-reference role,' 'relational construct,' and 'shared compatible choice of semantic conventions C,' and the paper does not show how the claimed equality follows from that definition. Because the tutorial's stated deliverable is a 'precise vocabulary,' this gap is load-bearing; please provide a formal or at least precisely operational definition, or explicitly reframe these equalities as illustrative judgments rather than as consequences of the definition.","section":"§2, 'Relational pattern structure' and Figure 6"},{"comment":"The definition quantifies over 'every shared compatible choice of semantic conventions C,' but the only demonstrated equality uses one convention (C_Soufflé for e1 and e2). The paper itself notes that e3 and e4 have different native query mappings and only become equal under a shared C, so without a characterization of which choices of C are 'compatible,' the equivalence relation is not well-defined. Please either characterize the allowed conventions or explain why equality under a representative shared convention is the intended notion and how that supports the 'every' quantification.","section":"§2, pattern-isomorphism definition"},{"comment":"The definition of pattern isomorphism also depends on 'aligned dissociated inputs' and on the preservation equation q_e,(S2,C)(I2)=q'_e,(S2,C)(I'_2). The paper does not give a general statement of when this preservation holds (e.g., how schema constraints are dropped in the dissociated schema) or how two dissociated schemas with different relation signatures are aligned. Please state this preservation property as a formal lemma with explicit hypotheses, or restrict its use to the specific examples so that the boundary between definition and example is clear.","section":"§2, 'Dissociation and relational pattern denotation'"}],"minor_comments":[{"comment":"The phrase 'the same relational core' is used before relational pattern structure is formally introduced; consider flagging this as an intuitive preview to avoid seeming to presuppose the later definition.","section":"§2, paragraph after Figure 2"},{"comment":"The paper cites Wikipedia for linguistic relativity [74]; a standard scholarly reference would be more appropriate for a published tutorial proposal.","section":"References"},{"comment":"The list of core concepts and languages is dense; a table mapping each language to the specific concept it illustrates would help readers and attendees navigate the tutorial.","section":"§4 'Core concepts'"},{"comment":"The distinction between 'structural notation' and 'surface notation' is introduced in a footnote but the main text often uses 'notation' loosely; consider using the more specific terms consistently.","section":"Footnote 2 and Section 2"}],"recommendation":"major_revision","confidential_remarks":"The stress-test concern lands: the informal definition of pattern isomorphism is the load-bearing weakness of the paper, and it is fixable in a revision. The worked examples are correct and the tutorial covers a useful design space, so I would not reject. One additional consideration for the editor: the paper is substantially self-referential, building on the author's own ARC, Relational Diagrams, and prior tutorial; this is not circular, but it means the framework is not independently validated beyond the author's prior work. A short formal appendix or a reframing of the precision claims would materially improve the paper's fit with PVLDB."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Dear colleague,\n\nThe short version: this is a tutorial proposal, not a research paper. It contains no new theorem, no data, and no falsifiable prediction. But for someone interested in relational language design or the AI-query-generation shift, it is a genuinely useful synthesis, and the five-level vocabulary is a real step toward clarity. The best part is the worked examples: the SQL/Soufflé empty-aggregate difference and the e_group vs. e3/e4 contrast are exactly right, and they make the separation of semantic conventions from relational pattern concrete before any formalism appears.\n\nThe paper is honest about being an extension of the author's own ARC and Relational Diagrams line. That is not a flaw here: it extends the prior SIGMOD tutorial with recursion, nested data, and beyond-PTIME material, and those sections read as fair surveys. The new terms—information need, query mapping, relational pattern structure, pattern denotation, semantic conventions—are refinements of earlier concepts, but they are coherent, and the dissociation trick (renaming table references to expose roles) is a nice pedagogical device.\n\nThe soft spot is exactly where the stress-test puts it. Relational pattern structure and pattern-isomorphism are only defined informally. The paper states P_e1=P_e2=P_e3=P_e4 without deriving it from the definition, and the definition quantifies over \"every shared compatible choice\" of semantic conventions while the examples only demonstrate equality under one convention (Soufflé-style set semantics). If the framework is meant to be a precise analytical tool, that gap matters. For a tutorial, it is less damaging, but the abstract promises \"a precise vocabulary,\" and that promise is not fully backed. A serious referee should ask for either a sharper partial formalization (e.g., within ARC) or a more modest claim about precision.\n\nOther limitations are minor: no empirical evaluation, heavy reliance on the author's prior constructs, and a very wide survey in the extended sections. None undercut the tutorial's core value.\n\nWho is this for: database researchers thinking about language design, notation, and query readability in an era of generated queries. It deserves a serious referee—a tutorial proposal with this level of thought should be reviewed rather than desk-rejected. I would not cite it in my own research in the next year unless I were working directly on this vocabulary, but I would happily point a student toward it.\n\nRecommendation: send to peer review, with the informality of pattern-isomorphism flagged as the main revision point.","headline":"A coherent and useful tutorial proposal whose central new vocabulary is only informally pinned down; worth a serious referee, but the 'precise vocabulary' promise needs either tightening or softening.","tokens_in":15006,"tokens_out":3710,"would_cite":false,"duration_ms":34961,"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":"Query languages should be compared by the relational patterns they expose, not just by what they can express.","keywords":["relational query languages","relational pattern structure","query design vocabulary","semantic conventions","query readability","AI-assisted query generation","Abstract Relational Calculus","Relational Diagrams"],"falsifier":"A concrete check: take two expressions that the paper's alignment procedure judges pattern-isomorphic; if there exists any compatible semantic convention and any aligned dissociated inputs on which their dissociated denotations differ, then pattern isomorphism as defined fails to be a well-defined equivalence. A complementary experiment: present the same machine-generated query to users in two notations, one that exposes the correlated subcollection pattern and one that buries it under surface syntax; if reading and revision performance does not differ measurably, the claimed cognitive benefit of making patterns explicit is unsupported.","tokens_in":14011,"feed_emoji":"🧩","tokens_out":6226,"duration_ms":50097,"temperature":0.7,"pith_summary":"This paper argues that relational query languages differ in more than what they can compute: they differ in which relational structures they make explicit and how easily a reader can recognize and revise those structures. The author proposes a vocabulary that separates an informal information need, the formal query mapping, the notation-independent relational pattern structure, the pattern's denotation under independent role inputs, and language-level semantic conventions such as empty-aggregate behavior. Through running examples in SQL and Datalog-style languages, the paper shows that two expressions can answer the same information need with the same pattern structure yet different results under native conventions, while two expressions with the same query mapping can instantiate different pattern structures. The claimed payoff is a framework for comparing existing and future relational languages, relevant now that machines generate queries and humans must read, verify, and revise them.","feed_headline":"Judge query languages by the relational patterns they expose","feed_subtitle":"Machines write queries; humans must read them. This tutorial separates notation from meaning in language design.","key_machinery":"The load-bearing object is the relational pattern structure $P_e$ of an expression $e$: the abstract way output values are derived from table-reference roles, abstracted from surface syntax, schema names, and semantic conventions. It is made precise operationally by dissociation, which replaces each table-reference occurrence with a distinct relation name so that the roles can vary independently; the dissociated expression's query mapping is the relational pattern denotation. Two expressions are pattern-isomorphic when a bijective alignment of roles and query-relevant attributes makes their dissociated denotations equal on every aligned input under every shared compatible choice of semantic conventions. The framework uses Abstract Relational Calculus (ARC) and Relational Diagrams as reference representations for comparing patterns across notations. This machinery carries the argument because it lets the same 'correlated subcollection summary' be recognized across SQL, Soufflé, different schemas, and different notational styles, and lets semantic conventions be identified as the source of behavioral differences.","core_discovery":"On the paper's own terms, the central discovery is that 'relational pattern structure' is a real, separable layer of a query, independent of surface notation and semantic conventions, and that recognizing this layer resolves debates that otherwise collapse into questions of logical expressiveness. Two queries may share the same information need and the same pattern structure while denoting different query mappings under their native semantic conventions (the SQL NULL versus Soufflé 0 empty-sum case); two queries may have the same query mapping over a schema and yet instantiate different pattern structures (GROUP BY versus a correlated double reference to the same relation). Pattern isomorphism is defined informally via dissociation: rename each table-reference role to a fresh relation name, then align roles across expressions so that the dissociated denotations agree on all aligned inputs under every shared compatible choice of semantic conventions. The paper claims this alignment shows queries as different as an employee-sales aggregation and a grouped self-join over a single relation are instances of one correlated subcollection summary.","pith_inferences":["If relational pattern structure can be given a precise, language-independent definition, a natural next step is automated pattern-preserving query rewriting: transform a query between notations while certifying that the dissociated denotation is unchanged.","A testable human-factors extension would compare readers' speed and accuracy in revising machine-generated queries under notations that expose the same pattern structure versus notations that obscure it; the framework predicts the exposed-pattern notations win.","The pattern-isomorphism criterion could serve as a correctness target for LLM query generation: a generated query is faithful not when it produces the same result on one instance but when its dissociated denotation matches the intended pattern under independent role inputs.","The relational versus graph language divide may be partly a matter of pattern presentation; path queries expressed relationally and graphically could be compared by pattern isomorphism rather than by data model allegiance."],"forward_implications":["Language design debates should be reframed: expressive power is one axis; pattern structure made explicit and readability and revising support are separate axes.","Two queries with the same query mapping can still be genuinely different designs, and two queries with different native results can share the same relational pattern; neither observation is a contradiction once semantic conventions are separated.","For machine-generated queries, the framework gives a vocabulary for asking whether a generated expression exposes the same relational pattern as the user's information need, and for revising it while preserving pattern structure.","The tutorial extends the framework to recursive and path queries, nested relational data, and languages beyond PTIME, claiming the same pattern-focused comparison applies in those settings."],"supporting_citations":[{"why":"Supplies the Abstract Relational Calculus (ARC) used as the reference representation for comparing relational patterns across notations.","marker":"[32]"},{"why":"Introduces Relational Diagrams and the notion of pattern expressiveness that the tutorial's vocabulary builds on.","marker":"[30]"},{"why":"Gives the fuller treatment of relational diagrams and pattern expressiveness behind the illustrative examples.","marker":"[29]"},{"why":"Is the earlier SIGMOD tutorial that this tutorial extends with recursion, nested data, and beyond-PTIME languages.","marker":"[28]"},{"why":"Documents the shift from human query composition toward machine generation and human interpretation that motivates the framework.","marker":"[31]"},{"why":"Provides the 'query mapping' terminology the paper adopts for the denotation of an expression under a semantic background.","marker":"[4]"},{"why":"Supplies the 'notation as a tool of thought' rationale for caring about how notation makes structure explicit.","marker":"[43]"},{"why":"Frames expressive power as the traditional central criterion that the paper argues is insufficient.","marker":"[19]"},{"why":"Fixes the Soufflé empty-aggregate convention (0) that drives the running example's semantic-convention difference.","marker":"[2]"},{"why":"Describes SQL's conceptual evaluation strategy, which the example contrasts with Soufflé's semantics.","marker":"[61]"}],"fun_headline_variants":["Relational patterns, not syntax, define query meaning","Query languages judged by the patterns they expose","Pattern structure: the hidden layer in query design","Separating query notation from semantic conventions","Relational pattern structure: key to query language comparison"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The framework rests on the assumption that relational pattern structure is a well-defined, language-independent notion that can be identified across notations; if the informal alignment criterion for pattern isomorphism cannot be made precise, or if pattern structure does not correspond to any real advantage in reading and revising queries, the framework's value collapses.","fun_headline_variants_meta":{"raw":{"variants":["Relational patterns, not syntax, define query meaning","Query languages judged by the patterns they expose","Pattern structure: the hidden layer in query design","Separating query notation from semantic conventions","Relational pattern structure: key to query language comparison"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000176,"raw_usage":{"total_tokens":1297,"prompt_tokens":963,"completion_tokens":334,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":579,"completion_tokens_details":{"reasoning_tokens":264}},"tokens_in":579,"tokens_out":334,"duration_ms":3583,"temperature":1.0,"reasoning_tokens":264,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T00:09:32.265067+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"A concrete check: take two expressions that the paper's alignment procedure judges pattern-isomorphic; if there exists any compatible semantic convention and any aligned dissociated inputs on which their dissociated denotations differ, then pattern isomorphism as defined fails to be a well-defined equivalence. A complementary experiment: present the same machine-generated query to users in two notations, one that exposes the correlated subcollection pattern and one that buries it under surface syntax; if reading and revision performance does not differ measurably, the claimed cognitive benefit of making patterns explicit is unsupported.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the Abstract Relational Calculus (ARC) used as the reference representation for comparing relational patterns across notations."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Introduces Relational Diagrams and the notion of pattern expressiveness that the tutorial's vocabulary builds on."},{"cited_title":"On The Reasonable Effectiveness of Relational Diagrams: Explaining Relational Query Patterns and the Pattern Expressiveness of Relational Languages","cited_arxiv_id":"2401.04758","evidence_quote":"Gives the fuller treatment of relational diagrams and pattern expressiveness behind the illustrative examples."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Is the earlier SIGMOD tutorial that this tutorial extends with recursion, nested data, and beyond-PTIME languages."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Documents the shift from human query composition toward machine generation and human interpretation that motivates the framework."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the 'notation as a tool of thought' rationale for caring about how notation makes structure explicit."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Frames expressive power as the traditional central criterion that the paper argues is insufficient."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Fixes the Soufflé empty-aggregate convention (0) that drives the running example's semantic-convention difference."}],"review_version":1}