Pith. sign in

REVIEW 3 major objections 7 minor 36 references

Extending Desbordante with Probabilistic Functional Dependency Discovery Support

T0 review · 3 major / 7 minor · reviewed 2026-07-30 · grok-4.5

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Probabilistic functional dependencies are not interchangeable with approximate ones: at the same error threshold they return different minimal rules, so AFD discovery cannot serve as a proxy for pFDs.

desk verdict Real open pFD implementation plus careful cost/output comparison to g1-AFDs; the non-interchangeability claim is directionally right but the value evidence and PerValue/TANE fit are thinner than the tables suggest. read the letter →

arxiv 2607.23636 v1 pith:ADV5M33I submitted 2026-07-26 cs.DB cs.AIcs.CEcs.LG

Ilia Barutkin , Maxim Fofanov , Sergey Belokonny , Vladislav Makeev , George Chernishev This is my paper · ORCID
classification cs.DBcs.AIcs.CEcs.LG
keywords dataprofilingprobabilisticfunctionaldependenciesapproximateTANEg3metricrelaxedposition-listindex
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Real tables are dirty, so exact functional dependencies almost never hold and profilers must relax them. The popular relaxation is the approximate functional dependency (AFD) based on a g1-style pair-error; another, less-studied relaxation is the probabilistic functional dependency (pFD) based on the g3-style fraction of tuples that must be deleted. This paper shows, with both hand-built examples and counts on public CSVs, that the two notions tolerate different violation patterns and that the sets of minimal rules they return are not subsets of each other. It then supplies the first open-source C++ implementation of pFD discovery (a TANE variant supporting both PerValue and PerTuple probabilities), measures its run-time and memory against an AFD baseline, and concludes that both primitives belong in a science-intensive profiler because neither can substitute for the other.

What carries the argument

pFDTane — a lattice-traversal algorithm obtained from TANE by replacing the candidate-validation step with the PerValue or PerTuple probability (equivalently 1-g3) computed from position-list indexes.

What would settle it

Run both discoverers on a data set that has a known gold-standard set of true functional dependencies (or a downstream cleaning/deduplication task with a measurable quality metric) and check whether the pFD-only rules improve recall, precision or end-task accuracy relative to the AFD-only rules at matched error thresholds.

Watch

Extended reading notes

Core claim

With a fixed numeric error threshold, the minimal non-trivial pFDs (PerValue or PerTuple) discovered on a relation are in general neither a subset nor a superset of the minimal AFDs; some pFDs are not even inferable from the AFD set. Consequently an AFD discovery algorithm cannot be used as a faithful proxy for pFD discovery, and vice versa. Empirically the pFD validator is slower than the AFD validator yet often consumes less memory.

Load-bearing premise

That counting extra or missing minimal rules on a handful of public CSVs, plus two toy tables, is enough to prove that the two notions give end-users genuinely different value.

Editorial extensions

If this is right

  • A profiler that already offers AFDs should also offer pFDs if it wants to cover the full range of g1/g3-style relaxations.
  • Users who care about “local” sensor-style faults (few distinct LHS values that are heavily corrupted) will prefer PerValue pFDs; users who care about global tuple deletion will prefer PerTuple or AFDs.
  • Because pFD discovery is slower but leaner in memory, implementers can trade the two resources by choosing which primitive to expose first.
  • Existing AFD result sets cannot be post-processed into pFD result sets without re-running validation under the other metric.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same lattice infrastructure can be reused for any other g3-based primitive (approximate INDs, GEDs, AITFDs) simply by swapping the validation oracle.
  • A hybrid error measure that mixes PerValue and pair-counting could give analysts a continuous knob between the two violation styles the paper separates.
  • If downstream tools begin to consume pFD confidence scores rather than binary AFD flags, the slower validation cost may be amortised by richer ranking and explanation features.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 7 minor

Summary. The manuscript adds probabilistic functional dependency (pFD) discovery to the Desbordante profiler and studies pFDs relative to approximate functional dependencies (AFDs). The authors (i) review the g1/g2/g3 metric family and the relaxed-dependency literature built on it; (ii) give qualitative toy examples (Tables IV–V, Observations 1–2) showing that the PerValue and PerTuple measures respond differently to error patterns than the g1-based AFD error e; (iii) implement pFDTane by swapping the candidate-validation function of their TANE implementation with PLI-based PerValue/PerTuple validators; and (iv) evaluate run time and memory across nine public datasets with repeated runs and 95% confidence intervals (RQ2–RQ4), and compare the sets of minimal dependencies returned by AFDTane and pFDTane on monkeypox.csv (Table VI, RQ1). The headline claims are that minimal pFDs and minimal AFDs are mutually non-contained at a fixed error threshold — including pFDs not inferable from the minimal AFD set — and that pFDTane is typically slower but more memory-frugal than AFDTane.

Significance. If the results hold, the paper makes a useful systems contribution: to the authors' knowledge the first open-source C++ pFD discovery implementation, integrated into a maintained profiler and released via a public pull request (PR 300), with dataset links provided. The empirical methodology is a strength for this venue: nine external datasets spanning three orders of magnitude in size, 10–30 repeated runs per configuration, reported confidence intervals, and both time and memory metrics. The qualitative analysis (Observations 1–2) is correct — I verified the arithmetic (PerValue 5/8, g3 3/11, e 3/55) — and cleanly establishes by construction that the measures weight violations differently. The related-work survey of g1/g2/g3-based primitives is a serviceable reference. The main risk to significance is that the quantitative half of RQ1 (Table VI) may partly measure threshold-scale mismatch rather than semantic divergence, and that the correctness of the PerValue discovery results rests on a monotonicity property the paper itself notes does not hold.

major comments (3)
  1. [§V.B, Table VI (RQ1 quantitative part)] The set-difference counts compare AFDs and pFDs at numerically equal error thresholds, but the three measures have different scales and semantics: e is a fraction of violating tuple pairs (normalized by |r|²−|r|), PerTuple = 1−g3 is a fraction of tuples to delete, and PerValue is an unweighted average of per-group majority fractions. For a size-n cluster with one offending tuple, e ≈ 2(n−1)/(|r|−1) while g3 = 1/|r|, and PerValue ignores cluster size entirely. Table VI itself shows the symptom: at ε=0.01 only 9–10 of ~130 minimal dependencies overlap. The large |pFDs \ AFDs| counts (133, 153) may therefore quantify '0.01 means different things in each metric' rather than genuine semantic divergence. The paper's own 'Non-inferable pFDs' column mitigates this only partially, and that residue is carried almost entirely by PerValue (PerTuple non-inferable counts are 1, 2, 0, 0, 2). The claim
  2. [§II (minimality remark) and §IV (Candidate Validation)] The paper correctly notes that PerValue is not preserved under LHS extension ('this is not always true in case of pFD PerValue'), i.e., the error measure is not anti-monotone in X. TANE's lattice pruning (vertex exclusion based on discovered minimal dependencies, and the C⁺-based candidate filtering) is sound only for anti-monotone error measures. The manuscript states that 'error measurement functions ... [are] the essentially only part which had to be changed' — i.e., the pruning logic is unchanged — but never discusses whether the pruning remains correct for PerValue. If it does not, the reported 'minimal pFD PerValue' sets (Tables VI and VIII) may be incomplete (missed minimal pFDs) or contain non-minimal ones, which would directly undermine the PerValue columns of Table VI that carry the RQ1 conclusion. The authors must either prove that the specific prunings they retain are safe fo
  3. [§IV, Algorithms 3 and 4] The pseudocode iterates over all tuples t ∈ R and appears to require the relation sorted by (X, A), which contradicts the surrounding text claiming PLI-based validation that 'does not iterate over single value clusters'. This matters specifically for PerValue: stripped partitions drop singleton clusters, but singletons both contribute probability 1 to the numerator and count toward |DX| in the denominator, so a validator over stripped PLIs cannot compute PerValue without separately tracking the number of stripped clusters. As written it is unclear what the implementation actually does. Additionally, both listings omit the final-group flush (the last cluster's maxCount/count is never added to sum after the loop ends), and count(c′) is reset to 0 rather than 1 on group transitions. Please reconcile the pseudocode with the PLI-based implementation and state precisely how singleton clusters
minor comments (7)
  1. [§V.B, Table VI] The set-difference analysis is performed on a single dataset (monkeypox.csv). Even a qualitative spot-check on one or two additional datasets from Table VIII would strengthen the generalizability of the RQ1 conclusion, and would help separate threshold artifacts from dataset-specific effects.
  2. [§V.C, Table VII] The caption reads 'EXACT FDs DISCOVERY TIME AND MEMORY' but the section measures candidate-validation cost of the three validators at error 0 as a proxy. Since error 0 collapses all three measures to exact FD checking, the table primarily reflects per-candidate validator overhead; please state this interpretation explicitly and clarify that lattice traversal is identical by construction.
  3. [§V.E, Tables XI–XII] Memory ratios are constant (to three decimals) across nearly all error thresholds for most datasets (e.g., 0.356 for jena_climate, 0.127 for nuclear_explosions). This suggests memory is dominated by threshold-independent structures (PLIs); a one-sentence explanation would preempt reader confusion. Also, absolute AFDTane memory in Table VII is suspiciously flat (1490–1491 MB across five datasets of very different sizes) — worth a comment on the measurement method.
  4. [§V.A] The AFD threshold subset (captions of Tables IX–XII, 0.025–0.5) is justified by user relevance, but Table VI uses 0.01–0.3 and Table VIII uses 0.01; please harmonize or explain the three different grids. Also state explicitly whether 'error threshold' for pFDs means 1−p throughout.
  5. [Figures 2–4] Axis labels and legends are partly garbled in the rendered figures (e.g., 'nuclear_expl si ns', 'E icVitals', ' arking_citations'), and Figure 4's y-axis mixes 'MB' and 'bytes' units. Legends in Figures 3–4 are dense; consider per-dataset panels or tables.
  6. [Throughout] Minor language issues: 'quantatively' (§V.B), 'how much AFDs are lost by it', 'lets denote', 'data interpretation and data context leave room for both of them' (§VI). The UML diagram (Fig. 1) is low-resolution and its caption does not explain the aggregation/composition relations the text refers to.
  7. [§II] The pFD definition block has notational rough edges: '(VY, VX1)' is used as a set name, 'X1 attributes of X' is garbled, and the argmax in the definition of the majority-value subset is not defined for ties. A cleaner restatement in terms of per-equivalence-class majority frequency would help readers.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: empirical systems paper measuring external metrics on external data

full rationale

The paper implements pFD discovery (PerValue/PerTuple from Wang et al.) inside Desbordante by adapting TANE’s lattice search and swapping only the candidate-validation error functions (Listings 3–4). Qualitative differences from AFDs are arithmetic consequences of the published metric definitions (Obs. 1–2 on toy tables; g3 ≡ 1−PerTuple stated explicitly). Quantitative claims (set differences in Table VI, runtime/memory ratios in Tables VII–XII) are measured on public CSVs under stated thresholds, not fitted parameters re-labeled as predictions, and not forced by self-referential normalization. Self-citations to Desbordante are infrastructural (host tool, prior FD/AFD code) and do not underwrite the pFD-vs-AFD divergence or performance results. No uniqueness theorem, ansatz, or renamed known law is load-bearing. Threshold-scale mismatch between e, g3, and PerValue is a validity concern about interpretation of Table VI, not circular derivation.

Assumptions & free parameters 2 free parameters · 5 assumptions · 0 invented entities

Load-bearing content is almost entirely inherited definitions (FD, g1/e, g3, PerValue, PerTuple, TANE lattice + PLIs) plus engineering choices (error grid, dataset suite, minimality). No new physical entities. Free parameters are experimental knobs (error thresholds, run counts), not fitted scientific constants.

free parameters (2)
  • error threshold grid (0–1, step 0.025; AFD subset of thresholds) = 0 to 1 step 0.025; AFD tables use selected low errors e.g. 0.025–0.5
    User-chosen maximum error that defines which candidates count as pFDs/AFDs; all output-count and many timing conclusions are conditioned on these values.
  • repetition count for timing (10 runs; 30 for measures_v2) = 10 (20 extra on measures_v2)
    Chosen to stabilize means and 95% CIs; affects reported performance confidence, not the dependency definitions.
assumptions (5)
  • domain assumption Classical FD satisfaction: equal X-projections imply equal Y-projections on all tuple pairs.
    Section II baseline; all relaxations are defined relative to this.
  • domain assumption Modern AFD error e is the normalized count of violating pairs (modified g1) as in PYRO/Kruse–Naumann.
    Adopted explicitly so Desbordante AFDs match the ‘modern definition’ used in experiments.
  • domain assumption pFD probability via PerValue (average of per-X-value majority fractions) and PerTuple (size-weighted majority mass), with PerTuple = 1 − g3.
    Taken from Wang et al.; Section II formulas are used unchanged for validation.
  • domain assumption TANE-style levelwise lattice search with PLI/stripped partitions is a correct complete method for enumerating minimal non-trivial dependencies once the error oracle is swapped.
    Section IV integration assumes classical TANE pruning still applies for pFD minimality under the chosen metrics (with a noted caveat that PerValue does not always allow arbitrary LHS growth).
  • ad hoc to paper Public CSV benchmarks and FD/AFD/pFD counts at ε=0.01 are representative enough to answer cost and overlap RQs.
    Dataset suite in Table VIII is an author selection; no sampling argument that results generalize beyond these tables.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Extending Desbordante with Probabilistic Functional Dependency Discovery Support." pith.science (2026). https://pith.science/paper/ADV5M33I

@misc{pith2026260723636,
  author       = {Pith},
  title        = {Pith review of: Extending Desbordante with Probabilistic Functional Dependency Discovery Support},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ADV5M33I}},
  note         = {Machine review of arXiv:2607.23636}
}
read the original abstract

Data profiling aims to extract complex patterns from data for further analysis and use that data in domains such as data cleaning, data deduplication, anomaly detection, and many more. Functional dependencies (FDs) are one of the most well-known patterns. However, they are poorly suited for these tasks, as real data is usually dirty, and the rigid definition of FDs does not allow algorithms to locate them. For this reason, there are several formulations aimed at relaxing FDs to support dirty data, with approximate functional dependency (AFD) being the most popular one. Another formulation is the Probabilistic Functional Dependency (pFD), which we aim to support inside Desbordante - a science-intensive, high-performance and open-source data profiling tool implemented in C++. However, pFDs are relatively poorly studied, compared to AFDs. In this paper we study pFDs, both analytically and empirically. We start by assessing how different pFDs and AFDs are by studying cases in which pFDs have an edge over AFDs. Then, we implement the algorithm for pFD discovery, as well as study its run time and memory consumption. We also compare it with an AFD discovery algorithm. Lastly, we study the output of both algorithms to learn whether or not it is possible to use AFD discovery algorithm to get pFDs and vice versa.

Figures

Figures reproduced from arXiv: 2607.23636 by the authors.

Figure 1
Figure 1. UML class diagram TABLE IV EXAMPLE CASE 1 X Y 0 1 0 2 0 3 0 4 0 5 ... ... 1 1 2 2 3 3 4 4 5 5 6 6 TABLE V EXAMPLE CASE 2 X Y 0 1 0 1 0 1 0 1 0 1 1 1 1 2 2 3 2 4 3 5 3 6 RAM overhead. Turning to performance, we want to stress the fact that this also does not negatively affects our study, since all experiments either compare methods relatively, or they compare algorithm output. For pFD PerValue and pFD PerTuple algori… view at source ↗
Figure 2
Figure 2. pFDTane running times AFDs that have X in LHS. That implies pf d1, pf d2 are in set of all AFDs. In order to highlight the essential difference of pFDs, we have also included in the table the number of minimal pFDs that are neither in the set of minimal AFDs nor inferable from it. Concluding this RQ, we can say that pFDs have their own strengths, and that they are different from AFDs. Specifically, having fixed erro… view at source ↗
Figure 3
Figure 3. Running time by error threshold TABLE IX RATIO OF RUNNING TIME OF AFDTANE AND PFDTANE PERVALUE ALGORITHMS Dataset Error threshold 0.025 0.05 0.075 0.1 0.15 0.2 0.25 0.3 0.4 0.5 BKB WaterQualityData 2020084 2.529 2.199 2.010 1.763 1.432 1.267 1.128 1.076 1.050 1.027 EpicVitals 2.671 2.637 2.623 2.589 2.145 1.952 1.679 1.636 1.548 1.547 jena climate 2009 2016 1.455 1.475 1.470 1.359 1.387 1.316 1.308 1.322 1.320 1.360… view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Maximum memory consumption by error threshold [PITH_FULL_IMAGE:figures/full_fig_p012_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

36 extracted references · 2 canonical work pages

  1. [1]

    Abedjan, L

    Z. Abedjan, L. Golab, F. Naumann, and T. Papenbrock, Data Profiling. Morgan & Claypool Publishers, 2018

    2018

  2. [2]

    Functional depe ndency discovery: An experimental evaluation of seven algorithms ,

    T. Papenbrock, J. Ehrlich, J. Marten, T. Neubert, J.-P . R udolph, M. Sch¨ onberg, J. Zwiener, and F. Naumann, “Functional depe ndency discovery: An experimental evaluation of seven algorithms ,” Proc. VLDB Endow. , vol. 8, no. 10, p. 1082–1093, Jun. 2015. [Online]. Available: https://doi.org/10.14778/2794367.2794377

    arXiv 2015

  3. [3]

    Inclusion dependency discovery: An experi mental evaluation of thirteen algorithms,

    F. D¨ ursch, A. Stebner, F. Windheuser, M. Fischer, T. Fri edrich, N. Strelow, T. Bleifuß, H. Harmouch, L. Jiang, T. Papenbrock , and F. Naumann, “Inclusion dependency discovery: An experi mental evaluation of thirteen algorithms,” in Proceedings of the 28th ACM International Conference on Information and Knowledge Management, ser. CIKM ’19. New Y ork, NY...

    arXiv 2019

  4. [4]

    C. C. Aggarwal and J. Han, Frequent Pattern Mining . Springer Publishing Company, Incorporated, 2014

    2014

  5. [5]

    Bhunt: Automatic discovery of fuzzy algebraic constraints in relational data,

    P . G. Brown and P . J. Hass, “Bhunt: Automatic discovery of fuzzy algebraic constraints in relational data,” in Proceedings of the 29th International Conference on V ery Large Data Bases - V olume 2 9, ser. VLDB ’03. VLDB Endowment, 2003, p. 668–679. 0.0 0.2 0.4 0.6 0.8 1.0 47.7 MB 95.4 MB 143.1 MB 190.7 MB 238.4 MB 286.1 MB 333.8 MB 381.5 MB Memory BKB_...

    2003

  6. [6]

    Sherlock: A deep lea rning approach to semantic data type detection,

    M. Hulsebos, K. Hu, M. Bakker, E. Zgraggen, A. Satyanaray an, T. Kraska, c. Demiralp, and C. Hidalgo, “Sherlock: A deep lea rning approach to semantic data type detection,” in SIGKDD’19. New Y ork, NY , USA: Association for Computing Machinery, 2019, p. 1500 –1508

    2019

  7. [7]

    Farm: Hierarchical association rule mining a nd visualization method,

    P . Tsurinov, O. Shpynov, N. Lukashina, D. Likholetova, a nd M. Artyomov, “Farm: Hierarchical association rule mining a nd visualization method,” in Proceedings of the 12th ACM Conference on Bioinformatics, Computational Biology, and Health Inform atics, ser. BCB ’21. New Y ork, NY , USA: Association for Computing Machin ery,

  8. [8]

    Mdedup: d uplicate detection with matching dependencies,

    l. Koumarelas, T. Papenbrock, and F. Naumann, “Mdedup: d uplicate detection with matching dependencies,” Proc. VLDB Endow. , vol. 13, no. 5, p. 712–725, jan 2020. [Online]. Available: https://d oi.org/10. 14778/3377369.3377379

    arXiv 2020

Show all 36 references
  1. [9]

    Data profiling with Metanome,

    T. Papenbrock, T. Bergmann, M. Finke, J. Zwiener, and F. N aumann, “Data profiling with Metanome,” Proc. VLDB Endow. , vol. 8, no. 12, p. 1860–1863, Aug. 2015. [Online]. Available: https : //doi.org/10.14778/2824032.2824086

    2015

  2. [10]

    Desbordante: from benchmarking suite to high-performance science-intensive data profiler,

    G. Chernishev et al. , “Desbordante: from benchmarking suite to high-performance science-intensive data profiler,” CoRR, vol. abs/2301.05965, 2023

    2023 arXiv

  3. [11]

    [Online]

    Desbordante GitHub repository . [Online]. Available: https://github.com/ Mstrutov/Desbordante

  4. [12]

    Approximate discovery of fu nctional dependencies for large datasets,

    T. Bleifuß, S. B¨ ulow, J. Frohnhofen, J. Risch, G. Wiese , S. Kruse, T. Papenbrock, and F. Naumann, “Approximate discovery of fu nctional dependencies for large datasets,” in CIKM’16. New Y ork, NY , USA: Association for Computing Machinery, 2016, p. 1803–1812. [ Online]. Ava...

    2016

  5. [13]

    Fast Approximate Dis covery of Inclusion Dependencies,

    S. Kruse, T. Papenbrock, C. Dullweber, M. Finke, M. Hegn er, M. Zabel, C. Z ¨ ollner, and F. Naumann, “Fast Approximate Dis covery of Inclusion Dependencies,” in BTW 2017 , ser. LNI, B. Mitschang and et al., Eds., vol. P-265. GI, 2017, pp. 207–226. [Online]. Av ailable: https:...

    2017

  6. [14]

    Relaxed funct ional dependen- cies—a survey of approaches,

    L. Caruccio, V . Deufemia, and G. Polese, “Relaxed funct ional dependen- cies—a survey of approaches,” IEEE Transactions on Knowledge and Data Engineering , vol. 28, no. 1, pp. 147–165, 2016

    2016

  7. [15]

    Approximate inference of fu nctional dependencies from relations,

    J. Kivinen and H. Mannila, “Approximate inference of fu nctional dependencies from relations,” Theoretical Computer Science , vol. 149, no. 1, pp. 129–149, 1995, fourth International Conference o n Database Theory (ICDT ’92). [Online]. Available: https://www.scie ncedirect.com...

    1995

  8. [16]

    Efficient discovery of approxi mate dependencies,

    S. Kruse and F. Naumann, “Efficient discovery of approxi mate dependencies,” Proc. VLDB Endow. , vol. 11, no. 7, p. 759–772, mar

  9. [17]

    Functional dependency generation and applic ations in pay-as-you-go data integration systems,

    D. Z. Wang, X. L. Dong, A. D. Sarma, M. J. Franklin, and A. Y . Halevy, “Functional dependency generation and applic ations in pay-as-you-go data integration systems,” in 12th International W orkshop on the W eb and Databases, W ebDB 2009, Providence, Rhode Island, USA, June 2...

    2009

  10. [18]

    Discovering functional dependencies in pay-as - you-go data integration systems,

    D. Z. Wang, M. Franklin, L. Dong, A. D. Sarma, and A. Halevy, “Discovering functional dependencies in pay-as - you-go data integration systems,” Tech. Rep. UCB/EECS-200 9- 119, 2009. [Online]. Available: https://www2.eecs.berke ley.edu/Pubs/ TechRpts/2009/EECS-2009-119.pdf

    2009

  11. [19]

    Tane: An efficient algorithm for discovering functional and approxi mate depen- dencies,

    Y . Huhtala, J. K¨ arkk¨ ainen, P . Porkka, and H. Toivonen , “Tane: An efficient algorithm for discovering functional and approxi mate depen- dencies,” The Computer Journal , vol. 42, no. 2, pp. 100–111, 1999

    1999

  12. [20]

    Des- bordante: a framework for exploring limits of dependency di scovery algorithms,

    M. Strutovskiy, N. Bobrov, K. Smirnov, and G. Chernishe v, “Des- bordante: a framework for exploring limits of dependency di scovery algorithms,” in 2021 29th Conference of Open Innovations Association (FRUCT), 2021, pp. 344–354

    2021

  13. [21]

    [Online]

    TANE implementation in the Metanome project . [Online]. Avail- able: https://github.com/HPI-Information-Systems/pyr o/blob/master/ pyro-metanome/src/main/java/de/hpi/isg/pyro/algorithms/TaneX.java

  14. [22]

    Functional dependencies with predicates: What makes the g3-error easy to compute?

    S. Vilmin, P . Faure-Giovagnoli, J. Petit, and V . Scutur ici, “Functional dependencies with predicates: What makes the g3-error easy to compute?” in ICCS’23, ser. Lecture Notes in Computer Science, M. O. et al., Ed., vol. 14133. Springer, 2023, pp. 3–16. [Online]. Available: ...

    2023 doi

  15. [23]

    Discovery o f approximate (and exact) denial constraints,

    E. H. Pena, E. C. De Almeida, and F. Naumann, “Discovery o f approximate (and exact) denial constraints,” Proceedings of the VLDB Endowment, vol. 13, no. 3, pp. 266–278, 2019

    2019

  16. [24]

    Mining relaxe d functional dependencies from data,

    L. Caruccio, V . Deufemia, and G. Polese, “Mining relaxe d functional dependencies from data,” Data Mining and Knowledge Discovery , vol. 34, no. 2, pp. 443–477, 2020

    2020

  17. [25]

    Unary and n-ary inclusion dependency discovery in relational databases,

    F. D. Marchi, S. Lopes, and J.-M. Petit, “Unary and n-ary inclusion dependency discovery in relational databases,” Journal of Intelligent Information Systems , vol. 32, pp. 53–73, 2009

    2009

  18. [26]

    Bauckmann, U

    J. Bauckmann, U. Leser, and F. Naumann, Efficient and Exact Computation of Inclusion Dependencies for Data Integration, ser. Technische Berichte des Hasso-Plattner-Instituts f ¨ ur Softwaresystemtechnik an der Universit¨ at Potsdam. Univ.-V erlag, 2010. [Online]. Available: htt...

    2010

  19. [27]

    Scalable inclusion depende ncy discovery,

    N. Shaabani and C. Meinel, “Scalable inclusion depende ncy discovery,” in Database Systems for Advanced Applications , M. Renz, C. Shahabi, X. Zhou, and M. A. Cheema, Eds. Cham: Springer International Publishing, 2015, pp. 425–440

    2015

  20. [28]

    Efficient algor ithms for mining inclusion dependencies,

    F. De Marchi, S. Lopes, and J.-M. Petit, “Efficient algor ithms for mining inclusion dependencies,” in Advances in Database Technology — EDBT 2002, C. S. Jensen, S. ˇSaltenis, K. G. Jeffery, J. Pokorny, E. Bertino, K. B¨ ohn, and M. Jarke, Eds. Berlin, Heidelberg: Springer Be r...

    2002

  21. [29]

    Fastageds: fast approxi mate graph entity dependency discovery,

    G. Zhou, S. Kwashie, Y . Zhang, M. Bewong, V . M. Nofong, J. Hu, D. Cheng, K. He, S. Liu, and Z. Feng, “Fastageds: fast approxi mate graph entity dependency discovery,” in International Conference on W eb Information Systems Engineering . Springer, 2023, pp. 451–465

    2023

  22. [30]

    Mining approximate interval-bas ed temporal dependencies,

    C. Combi and P . Sala, “Mining approximate interval-bas ed temporal dependencies,” Acta Informatica , vol. 53, 09 2015

    2015

  23. [31]

    Approximate interval-based temporal depend encies: The complexity landscape,

    P . Sala, “Approximate interval-based temporal depend encies: The complexity landscape,” in 2014 21st International Symposium on Temporal Representation and Reasoning (TIME) . Los Alamitos, CA, USA: IEEE Computer Society, sep 2014, pp. 69–78. [Online ]. Available: https://doi....

    2014 doi

  24. [32]

    [Online]

    Links to the datasets used in experiments . [Online]. Available: https://gist.github.com/iliya-b/f67cf0aa8397ec0a5ab7849376ec8a31

  25. [33]

    Discovery of genuine functional de pendencies from relational data with missing values,

    L. Berti- ´Equille, H. Harmouch, F. Naumann, N. Novelli, and S. Thirumuruganathan, “Discovery of genuine functional de pendencies from relational data with missing values,” Proc. VLDB Endow. , vol. 11, no. 8, pp. 880–892, 2018. [Online]. Available: http : //www.vldb.org/pvldb/...

    2018

  26. [34]

    Single-column data profiling,

    H. Harmouch, “Single-column data profiling,” Ph.D. dis sertation, University of Potsdam, Germany, 2020. [Online]. Available : https: //publishup.uni-potsdam.de/frontdoor/index/index/docId/47455

    2020

  27. [2018]

    Available: https://doi.org/10.14778/31 92965.3192968

    [Online]. Available: https://doi.org/10.14778/31 92965.3192968

  28. [2021]

    Available: https://doi.org/10.1145/345 9930.3469499

    [Online]. Available: https://doi.org/10.1145/345 9930.3469499

Pith tools

Reviewed July 30, 2026 · model on record in the stance chip above.