{"id":"ac3aee82-a0c0-4e6f-bef7-5ddb88a69327","arxiv_id":"2607.04030","paper_version":1,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":5.0,"correctness_risk":"low","formal_verification":"none","parameter_count":4,"one_line_summary":"ParCFDFinder, a parallel C++ CFDFinder variant in Desbordante, discovers conditional functional dependencies up to 318× faster and with 14× less memory on average than the Java Metanome baseline.","lead":"ParCFDFinder reimplements and optimizes CFDFinder in C++ with parallel lattice traversal, delivering up to 318× speedup and 23× less memory than Metanome. This makes conditional functional dependency mining practical on commodity machines for tables with hundreds of thousands of rows.","discovery_kind":"extension","skeptic_critique":{"model":"grok-4.5","headline":"No significant objection identified","rationale":"The paper’s strongest claim is a measured engineering improvement, not a theoretical guarantee. The experiments (deterministic ordering for fair comparison, multi-dataset Table III, row/column/thread scaling) directly support the reported factors and the “first time on commodity hardware” statement. The reader correctly flags the fixed parameter slice as the softest point, yet that slice is the one used by the original CFDFinder paper and is therefore the fairest baseline; the algorithmic changes (bitmask pruning, batching, unique-value filtering) are strategy-agnostic for the dominant phase. Consequently the concern does not rise to a load-bearing threat that would move the verdict. A single additional strategy sweep would be the cleanest confirmation, but its absence does not invalidate the existing evidence. Verdict remains ACCEPT.","tokens_in":16927,"tokens_out":486,"duration_ms":5286,"concrete_test":"Re-run the full Table III suite under the Minimum-Confidence-and-Support strategy (and, if time permits, NegativeConstant expansion) with identical thresholds; if the geometric-mean speedup falls below ~20\times or the largest datasets still time out under 8 threads, the practicality claim for “hundreds of thousands of rows” would need qualification.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim (up to 318\times / avg 118\times speedup and up to 23\times / avg 14\times memory reduction vs Metanome CFDFinder, enabling practical CFD discovery on ~100k-row tables) is an empirical systems result. It is supported by a deterministic re-implementation that matches CFD counts when both finish, by explicit algorithmic changes (unique-value expansion, cover-mask pruning, batch processing, negative-constant reuse) plus lattice-level parallelization, and by row-/column-/thread-scalability plots that show the Java baseline timing out while ParCFDFinder finishes. The reader’s weakest assumption (narrow SupportIndependent+ConstantExpansion slice + secondary ordering) is real but secondary: the paper already states that pattern generation dominates (~99 % of runtime) and that the same optimizations apply under other strategies; the headline numbers are therefore best-case but not fabricated. No internal inconsistency, circularity, or missing correctness check undermines the claim for a data-profiling venue.","agreement_with_reader":"agree"},"referee_report":{"model":"grok-4.5","summary":"The paper reimplements and optimizes the state-of-the-art CFDFinder algorithm for conditional functional dependency discovery as ParCFDFinder in C++ inside the open-source Desbordante profiler (with Python bindings). Algorithmic changes target the dominant pattern-tableau generation stage (unique-value expansion, deferred cover construction via bitmasks, batch candidate processing, negative-constant reuse) plus lattice-level parallelization via a thread pool. Against the Java Metanome baseline, the authors report up to 318\times (avg. 118\times) wall-clock speedup and up to 23\times (avg. 14\times) memory reduction on public and synthetic datasets, with row-, column- and thread-scalability plots and a short medical case study. Correctness is checked by imposing a deterministic secondary ordering on equal-support patterns so that both implementations emit identical CFD counts when both finish.","tokens_in":17175,"tokens_out":890,"duration_ms":20432,"significance":"If the measured factors hold under realistic use, the work materially extends the practical reach of CFD mining: commodity machines can now finish on tables of order 10^5 rows that previously timed out. The open C++/Python integration into a maintained profiler, the explicit engineering of the 99 % bottleneck, and the reproducible comparison methodology are concrete contributions that data-profiling and data-quality researchers can immediately reuse. The result is incremental rather than foundational, yet it closes a clear usability gap left by the unmaintained Metanome prototype.","major_comments":[{"comment":"§VI.B–C and Table III evaluate only SupportIndependentStrategy + ConstantExpansionStrategy under one fixed parameter vector (5 % min support gain, 10 % max support drop, confidence 1.0, max tableau length 2000). While the authors correctly note that pattern generation dominates runtime, the headline practicality claim for “hundreds of thousands of rows” is therefore demonstrated only for this slice; a short sensitivity check (or at least a statement of expected behaviour) for NegativeConstant, Range and Partial-FD strategies listed in §IV would strengthen the central claim.","section":"§VI.B–C, Table III"},{"comment":"The “for the first time” phrasing in the abstract and §I is relative only to Metanome’s CFDFinder. Related-work algorithms (FastCFD, CTANE, CFUN) already target different arity/support regimes; a one-paragraph clarification of the precise regime in which ParCFDFinder is newly practical would avoid over-claiming relative to the broader literature.","section":"Abstract, §I"}],"minor_comments":[{"comment":"Table II omits several datasets that appear in Table III (Avocado Prices, nursery). Adding their row/column/size statistics would make the experimental corpus self-contained.","section":"Table II vs Table III"},{"comment":"Figures 2–4 use a log y-axis for time yet still mark “timeout” only for Metanome; a short caption note that C++ runs never hit the three-hour limit would improve readability.","section":"Figs. 2–4"},{"comment":"The secondary ordering criteria introduced in §VI.A for determinism are described only at a high level (“compare the attribute values of the patterns”). A short formal definition or pseudocode fragment would aid re-implementation.","section":"§VI.A"},{"comment":"Minor typographical inconsistencies appear (e.g., “P roduct” with spaces in the introduction example, mixed “g1”/“g₁” notation). A final proof-reading pass would clean them.","section":"§I, §IV.D"}],"recommendation":"minor_revision","confidential_remarks":"Solid, well-executed systems paper that fits a data-management or data-quality venue. The evaluation scope is the only real limitation; once the authors add a short strategy-sensitivity paragraph the manuscript is ready for acceptance. No novelty or citation concerns."},"author_rebuttal":null,"desk_editor":{"model":"grok-4.5","letter":"This is a clean systems paper. What is new is ParCFDFinder: a C++ port of CFDFinder with four targeted changes (unique-value filtering on expansion, cover-mask deferred construction, batch processing of candidates, negative-constant reuse) plus a Boost.Asio thread-pool over independent lattice levels, all shipped inside Desbordante with a Python interface. The measured gains versus Metanome—up to 318\times / avg 118\times time, up to 23\times / avg 14× memory—are large enough that 100k-row tables become routine on ordinary hardware. That is a genuine practical advance for data-quality tooling.\n\nThey do the correctness work properly: they force a deterministic secondary order on equal-support patterns so both implementations emit identical CFD counts when both finish, and they supply full result tables plus row/column/thread scalability plots. Pattern generation is correctly identified as ~99 % of runtime, so the optimizations land where they matter. Memory stays flat with threads because the support map dominates. The case study is short but readable.\n\nSoft spots are real but secondary. Evaluation is locked to SupportIndependent + ConstantExpansion with fixed thresholds (5 % gain, 10 % drop, conf 1.0, max tableau 2000). The secondary ordering is only for reproducibility; real users may see different absolute numbers under other strategies. No one-command reproduction package is mentioned. None of this invents the speedups or breaks the central claim for a profiling venue.\n\nWho it is for: anyone building or using data profilers who needs CFDs on mid-size tables. The math is standard, the citations are honest (Grundke, Metanome, earlier Desbordante work), and the code is open. I would send it to peer review without hesitation; a systems track will find it useful. Worth citing if you touch CFD mining or Desbordante.","headline":"Solid engineering paper that makes CFD mining practical on 100k-row tables via C++ reimplementation, four concrete optimizations, and lattice parallelization; the 118\times average speedup is real under the tested slice.","tokens_in":17782,"tokens_out":495,"would_cite":true,"duration_ms":6003,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"grok-4.5","headline":"Algorithmic and engineering improvements plus parallel lattice traversal turn CFD discovery practical on commodity machines for tables of hundreds of thousands of rows.","keywords":["conditional functional dependencies","CFD discovery","data profiling","algorithm engineering","parallelization","data quality","pattern mining"],"falsifier":"Re-run the identical SupportIndependent + ConstantExpansion settings on the same tables with a different secondary pattern ordering or with an alternative pruning strategy (for example Partial FD or NegativeConstant) and check whether the reported 100 k-row times and memory factors still hold.","tokens_in":17876,"feed_emoji":"⚡","tokens_out":627,"duration_ms":5977,"temperature":0.7,"pith_summary":"Conditional functional dependencies (CFDs) capture rules that hold only inside a restricted context of the data; they are useful for data cleaning, complex constraints, and insight mining, yet discovering them is expensive. This paper starts from the prior CFDFinder algorithm, reimplements it in C++, and adds targeted optimizations—lightweight candidate patterns, bitmask-based cover pruning, batch processing, better data structures, and a thread-pool parallelization of independent lattice levels—yielding ParCFDFinder. Experiments on real and synthetic tables show speed-ups of up to 318\times (118\times on average) and memory reductions of up to 23\times (14\times on average) versus the existing Java implementation, so that tables with hundreds of thousands of rows can now be processed on ordinary hardware in reasonable time. The resulting code is integrated into an open-source C++ profiler that exposes a Python interface, making the faster algorithm immediately usable from ordinary data-science workflows.","feed_headline":"CFD discovery now practical on 100k-row tables","feed_subtitle":"Up to 318× faster and 23× less memory than the prior Java baseline, with a ready Python interface","key_machinery":"ParCFDFinder—the optimized, parallel CFDFinder pipeline whose core is a batched, bitmask-pruned pattern-generation stage together with a thread-pool lattice traversal that exploits independence of candidates at the same level.","core_discovery":"A carefully engineered C++ reimplementation of CFDFinder, augmented by deferred cover construction via bitmasks, elimination of duplicate pattern generation, batch processing of candidates, improved hash structures, and parallel traversal of independent lattice levels, produces ParCFDFinder that is up to 318 times faster and uses up to 23 times less memory than the prior Java baseline, thereby making CFD discovery practical for the first time on commodity machines for tables of hundreds of thousands of rows.","pith_inferences":[],"forward_implications":[],"fun_headline_variants":["ParCFDFinder: CFDs now practical on 100k-row tables","CFD discovery up to 318× faster, 23× less memory","Desbordante brings CFDFinder to large tables in C++","Batch lattice traversal cuts CFD mining time and memory","Python-ready CFD discovery for 100k+ rows on commodity PCs"],"cache_read_input_tokens":128,"weakest_assumption_plain":"The measured speed-ups and the claim of practicality rest on a fixed pruning/expansion configuration and a deterministic secondary ordering introduced only for reproducibility; different user-chosen strategies may change both runtime and the discovered CFD set.","fun_headline_variants_meta":{"raw":{"variants":["ParCFDFinder: CFDs now practical on 100k-row tables","CFD discovery up to 318× faster, 23× less memory","Desbordante brings CFDFinder to large tables in C++","Batch lattice traversal cuts CFD mining time and memory","Python-ready CFD discovery for 100k+ rows on commodity PCs"]},"model":"grok-4.5","effort":"low","cost_usd":0.00474,"raw_usage":{"total_tokens":1368,"prompt_tokens":771,"num_sources_used":0,"completion_tokens":77,"cost_in_usd_ticks":47400000,"prompt_tokens_details":{"text_tokens":771,"audio_tokens":0,"image_tokens":0,"cached_tokens":256},"completion_tokens_details":{"audio_tokens":0,"reasoning_tokens":520,"accepted_prediction_tokens":0,"rejected_prediction_tokens":0}},"tokens_in":771,"tokens_out":77,"duration_ms":5064,"temperature":1.0,"reasoning_tokens":520,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-07-11T22:11:11.608539+00:00","model_set":{"reader":"grok-4.5"},"falsifier":"Re-run the identical SupportIndependent + ConstantExpansion settings on the same tables with a different secondary pattern ordering or with an alternative pruning strategy (for example Partial FD or NegativeConstant) and check whether the reported 100 k-row times and memory factors still hold.","supporting_citations":[],"review_version":1}