{"id":"c8c5f7ff-adeb-4d6f-b4d7-91dfaa209d0c","arxiv_id":"2501.17859","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"rEGGression uses e-graphs to store and interactively explore large sets of symbolic regression expressions, with pattern matching and building-block distribution queries.","lead":"rEGGression is a new command-line tool that stores thousands of symbolic regression models in an e-graph and lets users search, filter, and pattern-match them. It also reports which small building blocks appear most often in the best models, which could help scientists find equations that match both the data and their prior knowledge.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Building-block distribution reports generic wildcard shapes (e.g., v0+(v1+v2)) rather than concrete recurring terms, so the main 'insight' feature is not demonstrated.","rationale":"I read the paper as a software demonstration whose central claim is that rEGGression enables interactive exploration of symbolic regression expressions, with pattern matching and building-block distribution as the distinctive features. The code is available and the command examples are concrete, which is real supporting evidence for the query and filtering functionality. The most load-bearing weakness is not the lack of comparative evaluation, though that exists, but the semantics of the building-block distribution itself. Algorithm 1 abstracts every leaf to a wildcard pattern variable, so the distribution reports syntactic shapes rather than concrete recurring subexpressions. Table 1 confirms this: all listed patterns are generic addition/subtraction templates. Such shapes are not 'building blocks' in the GP sense and cannot support the paper's promise of insight into the studied phenomena. This goes beyond the reader's representativeness concern: even with a perfectly representative sample, the output would be uninformative. The concrete test would settle the question by comparing random and ground-truth corpora. Thus I recommend keeping the CONDITIONAL verdict, conditioned on revising the distribution feature or demonstrating it on a known ground-truth problem, rather than accepting the current claim as stated.","tokens_in":14237,"tokens_out":5648,"duration_ms":61091,"concrete_test":"Build an e-graph from (a) a set of random expressions generated with the same grammar and (b) expressions from an SR run on a dataset with a known ground-truth term (e.g., a Feynman equation containing sin(x0)*exp(x1)). Run the distribution command on both. If the top patterns by fitness are identical generic wildcard shapes and the true domain term appears only after an explicit count-pattern query, then the automatic building-block distribution does not surface phenomenon-specific insights and the central claim should be revised.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"Section 4.9's distribution command and Algorithm 1 extract building blocks by replacing every leaf of a subtree with a wildcard pattern variable v. A leaf contributes [v, x]; a binary node contributes v plus op(lp,rp) for all combinations of child patterns. Consequently, the reported 'building blocks' in Table 1 are generic tree shapes such as v0+(v1+v2), not concrete recurring mathematical terms such as sin(x0) or exp(x1). The paper's main highlight, helping experts gain insights about the studied phenomena through building-block exploration, is not delivered by this output: the same wildcard shapes would dominate any grammar-constrained expression collection, independent of the data or the SR algorithm. The paper provides no evidence that the distribution can surface a domain-specific term, and the 'insight' claim therefore rests on an unsupported assumption that abstract syntactic shapes are informative building blocks.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper introduces rEGGression, a command-line tool that stores symbolic regression (SR) expressions in an e-graph data structure and provides interactive querying, filtering, pattern matching, and building-block distribution analysis. The tool can import expressions from several popular SR implementations and supports operations such as top-N retrieval with size/parameter filters, pattern matching with repeated pattern variables, subtree inspection, expression insertion, parameter optimization, Pareto-front display, and building-block counting. The authors demonstrate the tool on the nasa_battery_1 dataset using expressions produced by the eggp algorithm, and they describe the underlying e-graph pattern-matching algorithm with complexity bounds. The main claimed contribution is the ability to explore large sets of SR models and, in particular, to discover recurring building blocks that provide insights about the studied phenomenon.","tokens_in":14347,"tokens_out":5655,"duration_ms":57519,"significance":"If the tool works as described, it would fill a genuine gap: most SR tools only expose a final Pareto front or population, whereas rEGGression allows users to query and analyze the entire history of visited expressions from multiple algorithms. The e-graph-based storage and pattern matching, with support for repeated pattern variables, is a sensible and potentially efficient approach, and the open-source implementation and broad import format support are concrete strengths. The paper also provides a clear walk-through of all commands. However, the central 'insight' claim is currently not substantiated: the demonstrated building-block distributions consist of generic wildcard tree shapes rather than concrete recurring mathematical terms, and the paper offers no quantitative evidence of efficiency or stability of the reported statistics. These issues are fixable but are load-bearing for the paper's main promise.","major_comments":[{"comment":"The building-block distribution command produces only generic wildcard shapes such as (v0+(v1+v2)) and (v0+v1). Because Algorithm 1 replaces every leaf (terminal node) with a pattern variable v, any concrete term such as sin(x0) is subsumed into the pattern v0+(v1+v2) and its frequency is aggregated away. Consequently, the output in Table 1 is dominated by abstract tree shapes that would appear in any grammar-constrained expression collection, independent of the data or the SR algorithm. The paper's main highlight—that building-block exploration 'can help the experts to find insights about the studied phenomena' (Section 4.12)—is therefore not demonstrated. I recommend either modifying the extraction to preserve concrete terminals (e.g., by parameterizing the pattern variables with the cheapest concrete leaf) or providing a demonstration where a concrete, domain-specific term (e.g., sin(x0), exp(x1)) appears prominently in the distribution and is shown to lead to a useful query or new model.","section":"Section 4.9, Table 1, Algorithm 1"},{"comment":"The statistics reported by the distribution command are computed from the 'top y evaluated expressions' of a single run of a single algorithm (eggp on nasa_battery_1). The paper provides no argument or experiment showing that building-block frequencies and average-fitness rankings are stable across random seeds, hyperparameter settings, or different SR algorithms. Without such evidence, the reported 'insights' may be artifacts of the particular search history rather than properties of the data. Please either add a small stability analysis (e.g., repeat the distribution computation over multiple seeds and report rank correlations) or explicitly limit the claim to describing the search history rather than the phenomenon.","section":"Section 4.9"},{"comment":"The abstract and introduction state that e-graphs allow SR solution candidates to be stored and queried 'efficiently,' but the paper gives no quantitative evidence for this. The only data point is the note in Section 4.10 that 100,000 expressions produced a 200 MB save file. There are no measurements of e-graph construction time, pattern-matching latency (e.g., for count-pattern or distribution on a large database), or memory scaling as the number of expressions grows. Since the tool is positioned as an interactive exploration environment, I suggest including a small benchmark with varying numbers of expressions (e.g., 1k, 10k, 100k) measuring build time, query time for representative patterns, and memory usage. This would substantiate the efficiency claim and help users understand practical limits.","section":"Section 4.10 and abstract"}],"minor_comments":[{"comment":"The phrase 'semantically similar int the training set' contains a typo; it should be 'semantically similar in the training set'.","section":"Section 1"},{"comment":"In the subtrees example, the listed subtrees of (θ0*x3)+(θ1*x1) include 'θ0 x1', which is not a subtree, and omit the subtree 'θ1*x1'. The list should be 'θ0*x3, θ1*x1, θ0, θ1, x1, x3'.","section":"Section 4.4"},{"comment":"The text 'by diving the sum of fitness with the frequency of that pattern' should be 'by dividing the sum of fitness by the frequency of that pattern'.","section":"Section 4.9"},{"comment":"The comment on line 1 says 'build block' but should read 'building block'.","section":"Algorithm 1"},{"comment":"The import format description says the file is 'comma separated value format' but the second column is 'semicolon separated'; clarify how the CSV fields and the internal coefficient list separator interact.","section":"Section 4.10"}],"recommendation":"major_revision","confidential_remarks":"This is a tool paper with a useful, open-source implementation and a clear demonstration of the command set. The main technical concern—that the building-block distribution is dominated by wildcard shapes rather than concrete terms—is directly fixable and should be addressed before acceptance, as it underpins the paper's headline claim. The lack of any scalability or stability evaluation is also a significant gap for a tool whose value proposition is interactive exploration of large expression sets. I would encourage the authors to add a small benchmark and a stability check. The paper fits GECCO's scope, and the authors' prior related work is cited appropriately without being excessive."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"This is a better-than-average tool paper. It describes a working command-line program that stores symbolic-regression search histories in e-graphs and lets users query, filter, and pattern-match across them; source code and binaries are available, and the walk-through commands are concrete enough to reproduce. The reader's conditional verdict is about right.\n\nWhat is actually new: prior exploration tools (HeuristicLab, DataModeler, TuringBot) work on the final population or Pareto front of a single algorithm. rEGGression stores the whole visited-expression history from multiple runs and multiple algorithms in an e-graph, and then supports pattern queries like \"does this expression contain v0+v0\" or \"does it contain v0+sin(t0+x0)\". The pattern matching with repeated pattern variables is a genuine feature, and the e-graph machinery is a sensible fit. The citation pattern is fine: the authors build on their own earlier e-graph SR work, but they also ground the implementation in the external egg literature, and there is no circular reasoning in the evaluation.\n\nThe main soft spot is exactly what the stress-test note flags. The distribution command in Section 4.9 extracts building blocks by replacing every leaf with a wildcard variable. So Table 1 is all shapes like (v0+(v1+(v2+v3))) and (((v0/v1)+v2)+v3). These are generic syntactic forms that would appear in any grammar-constrained expression collection, independent of the data. The paper advertises building-block exploration as its main route to \"insights about the studied phenomena,\" but the demonstrated output cannot surface a domain-specific term like sin(x0) or exp(x1). That is a genuine gap, though not fatal: the count-pattern and matching commands do work on concrete patterns, so a user with a prior hypothesis can test it. The distribution feature itself, however, needs either a better extraction scheme (e.g., preserving concrete constants and leaves at some depth) or a much more honest framing.\n\nThe second soft spot is the lack of any systematic evaluation: one dataset, one algorithm, no seed or hyperparameter stability checks, no runtime or memory comparison. For a tool paper that is not necessarily disqualifying, but the representativeness of the \"top y evaluated expressions\" is assumed, and the 200 MB e-graph for 100k expressions suggests scalability deserves at least a short discussion.\n\nWho should read it: symbolic regression practitioners who want to inspect alternative models beyond the Pareto front, and GP researchers working on model interpretability. It deserves a serious referee: with revisions asking for a concrete building-block example, a multi-run stability check, and a scope clarification, it would be a solid contribution. I would accept it for review rather than desk-reject it.","headline":"A working e-graph-based query tool for SR histories, with a real caveat: the headline distribution feature reports only generic wildcard tree shapes, not the concrete recurring terms it promises to surface.","tokens_in":14896,"tokens_out":2296,"would_cite":true,"duration_ms":26686,"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":"rEGGression stores the entire history of a symbolic regression search in an e-graph, letting users query, filter, and mine thousands of alternative models and their building blocks.","keywords":["symbolic regression","e-graphs","equality saturation","pattern matching","building blocks","interactive exploration","genetic programming","exploration tool"],"falsifier":"Run the same regression dataset under, say, 30 different random seeds of the same symbolic regression algorithm, build a separate e-graph for each, and compare the top ten building blocks by count and by average fitness. If the rankings vary substantially between seeds, the building-block distribution is an artifact of the search trajectory rather than a stable property of the data, and the tool's interpretive value is limited to diagnostics of the search itself.","tokens_in":14007,"feed_emoji":"🔍","tokens_out":8672,"duration_ms":76980,"temperature":0.7,"pith_summary":"Symbolic regression usually returns a small Pareto front of accuracy-versus-complexity trade-offs; this paper argues that the many expressions visited during the search are themselves a valuable resource. It presents rEGGression, a tool that stores all visited expressions—from one run or many, from different algorithms—in an equality graph (e-graph), which merges duplicated sub-expressions into a compact, queryable structure. The user can ask SQL-like questions: which top models have fewer than five nodes, which expressions contain a damped-oscillator pattern, which sub-expressions appear most often, and which building blocks are associated with the best fitness. The central promise is that pattern matching and building-block statistics turn exploration from manually reading a few equations into systematic interrogation of the whole search space.","feed_headline":"A new tool mines every expression a regression search explored","feed_subtitle":"rEGGression uses e-graphs to filter thousands of models and reveal high-fitness building blocks.","key_machinery":"The load-bearing mechanism is the e-graph data structure, in which e-classes group provably equivalent sub-expressions and e-nodes point to child e-classes rather than to concrete tokens. This representation shares duplicated sub-trees across all stored expressions, which is what makes it feasible to hold hundreds of thousands of candidates in memory. The e-classes are indexed by a trie mapping operator tokens to e-class ids and their children; that index supports e-matching, the pattern-matching algorithm that returns every substitution map for a pattern such as `v0 + v1`, and it is used both for filtering expressions and for counting building-block occurrences. The same machinery also computes the distribution of building blocks up to a requested size, by recursively decomposing each expression's tree into pattern variables.","core_discovery":"The central claim is that the e-graph, a data structure invented for equality saturation in program optimization, can be repurposed as the backend of an interactive, algorithm-agnostic symbolic regression explorer. The paper demonstrates the design and commands of rEGGression, showing that storing tens of thousands of visited expressions (in the example, 100,000) in an e-graph keeps the database compact enough to query interactively, with pattern-matching queries returning results in reasonable time. The authors argue that by counting building-block patterns and ranking them by count or average fitness, users can find recurring structural motifs that drive accurate fits, and can then use those motifs to formulate new expressions to insert and test. Because the tool imports expression files from eleven common symbolic regression systems, the analysis applies across different search algorithms and hyper-parameter settings, making the exploration independent of any single search method.","pith_inferences":["The reported building-block frequencies and average fitnesses are statistics over the search history rather than over all plausible models; comparing their rankings across random seeds and algorithm configurations on a fixed dataset would show whether they reflect stable properties of the data or artifacts of the search trajectory.","The same pattern index could power an automated model-proposal step, listing the highest-fitness visited sub-expressions within a given size budget and suggesting recombinations, turning the tool from a query interface into a generator of new hypotheses.","Storing semantic properties per e-class—positivity, monotonicity, and measurement units—which the paper lists as future work, would allow constraint-based filtering and would let the tool enforce domain knowledge that cannot be expressed by syntactic patterns alone."],"forward_implications":["Users can impose structural prior knowledge after the search—requiring a pattern like `g(x)*exp(h(x))*cos(k(x))` or forbidding a recurrent motif—without re-running the symbolic regression algorithm.","Counting building blocks and averaging the fitness of expressions containing each one provides a data-driven shortlist of sub-expressions that contribute to accuracy.","Combining expressions from multiple symbolic regression runs and algorithms into one e-graph gives a larger, more diverse library of alternative models than any single Pareto front.","The ability to insert new expressions and re-optimize their parameters lets users test hypotheses formed from discovered building blocks immediately, closing a loop between analysis and search."],"supporting_citations":[{"why":"provides the e-graph and equality saturation implementation that rEGGression is built on.","marker":"[43]"},{"why":"supplies the relational e-matching algorithm used for pattern matching and building-block counting.","marker":"[44]"},{"why":"introduces equality saturation, the technique that motivates storing expressions as an e-graph.","marker":"[38]"},{"why":"the symbolic regression algorithm used in the paper's demonstration to populate the e-graph with 100,000 evaluated expressions.","marker":"[12]"},{"why":"prior work connecting equality saturation to symbolic regression, establishing the foundation this tool builds on.","marker":"[11]"},{"why":"companion study on redundant numerical parameters in symbolic regression, showing e-graph-based analysis of visited expressions.","marker":"[24]"},{"why":"an earlier exploration tool for symbolic regression ensembles whose feature set rEGGression extends with pattern matching and building blocks.","marker":"[21]"}],"fun_headline_variants":["E-graphs let you mine every expression a regression search tried","Explore 100,000 regression models with e-graph pattern search","rEGGression: interactive e-graph explorer for symbolic regression","Mine all symbolic regression runs with e-graph pattern queries"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The usefulness of the building-block statistics rests on the assumption that the set of expressions produced by the symbolic regression runs is representative enough for pattern frequencies and average fitnesses to be stable; the paper gives no evidence that these statistics do not change drastically across random seeds or algorithm configurations.","fun_headline_variants_meta":{"raw":{"variants":["E-graphs let you mine every expression a regression search tried","Explore 100,000 regression models with e-graph pattern search","rEGGression: interactive e-graph explorer for symbolic regression","Mine all symbolic regression runs with e-graph pattern queries"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00029,"raw_usage":{"total_tokens":1690,"prompt_tokens":932,"completion_tokens":758,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":548,"completion_tokens_details":{"reasoning_tokens":684}},"tokens_in":548,"tokens_out":758,"duration_ms":6649,"temperature":1.0,"reasoning_tokens":684,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T04:30:52.330451+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the same regression dataset under, say, 30 different random seeds of the same symbolic regression algorithm, build a separate e-graph for each, and compare the top ten building blocks by count and by average fitness. If the rankings vary substantially between seeds, the building-block distribution is an artifact of the search trajectory rather than a stable property of the data, and the tool's interpretive value is limited to diagnostics of the search itself.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"provides the e-graph and equality saturation implementation that rEGGression is built on."},{"cited_title":"Relational E-Matching","cited_arxiv_id":"2108.02290","evidence_quote":"supplies the relational e-matching algorithm used for pattern matching and building-block counting."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"introduces equality saturation, the technique that motivates storing expressions as an e-graph."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"prior work connecting equality saturation to symbolic regression, establishing the foundation this tool builds on."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"companion study on redundant numerical parameters in symbolic regression, showing e-graph-based analysis of visited expressions."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"an earlier exploration tool for symbolic regression ensembles whose feature set rEGGression extends with pattern matching and building blocks."}],"review_version":1}