Add CIND Cure Algorithm with Example and Tests by ALanovaya · Pull Request #729 · Desbordante/desbordante-core

ALanovaya · 2026-04-21T20:36:22Z

Summary

This PR adds the Cure condition mining algorithm to the CIND framework, complementing the existing CINDERELLA and PLI-CIND miners.

Background

A Conditional Inclusion Dependency (CIND) is an IND that holds only on the subset of rows matching a pattern condition on non-inclusion attributes (see #664 for the formal definition). Desbordante already provides CINDERELLA (itemset-based) and PLI-CIND (PLI-based) condition miners, both controlled by validity/completeness thresholds. Cure offers a different trade-off: it is controlled by a single support threshold (minimum number of joined tuples) and produces compact patterns with disjunctive RHS values.

The Cure algorithm

O. Curé (2012) discovers conditional patterns in two phases:

Discovery — for each approximate IND, enumerate pairs of (LHS conditional attribute, RHS conditional attribute) and hash-join rows on the inclusion key. For each joined LHS/RHS value pair, count co-occurrences and keep those with count ≥ support.
Minimal cover — merge patterns sharing the same (LHS conditional attribute, LHS value) key into a single tableau row. When multiple RHS values occur for the same LHS key, they are folded into a comma-separated disjunction in the corresponding RHS slot.

Per-pattern validity and completeness are derived from the pattern support and the total number of joined tuples.

Reference

O. Curé. "Improving the Data Quality of Drug Databases using Conditional Dependencies and Ontologies". ACM JDIQ 4(1):20, 2012.

Changes

CureCind (core/algorithms/cind/condition_miners/cure_cind.{h,cpp}) — new condition miner implementing the two-phase Cure algorithm.
AlgoType::cure_cind — added alongside existing cinderella and pli_cind in core/algorithms/cind/types.h.
CindAlgorithm dispatch — instantiates CureCind when algo_type = cure_cind (core/algorithms/cind/cind_algorithm.cpp).
min_support_ member added to CindMiner base class (used only by Cure).
support config option (core/config/conditions/support/option.{h,cpp}) — new minimum-tuples threshold, default 2.
Tests — three parameterized cases (support in {1, 2, 3}) added to src/tests/unit/test_cind_algorithms.cpp; a cind.algos test target is also wired up in the unit test CMakeLists.
Example — examples/basic/mining_cind_cure.py runs CINDERELLA and Cure on the same DBpedia German/English persons dataset and prints a side-by-side comparison.

Oddin60F · 2026-05-03T15:19:58Z

+struct VecIntHash {
+    std::size_t operator()(std::vector<int> const& vec) const noexcept {
+        return boost::hash_value(vec);
+    }
+};
+
+struct PairIntHash {
+    std::size_t operator()(std::pair<int, int> const& p) const noexcept {
+        std::size_t seed = 0;
+        boost::hash_combine(seed, p.first);
+        boost::hash_combine(seed, p.second);
+        return seed;
+    }
+};
+
+std::vector<int> MakeKey(std::size_t row, AttrsType const& cols) {
+    std::vector<int> key;
+    key.reserve(cols.size());
+    for (auto const* c : cols) {
+        key.push_back(c->GetValue(row));
+    }
+    return key;
+}


I think VecIntHash and MakeKey() should be moved to a separate namespace cind::utils. This will avoid code duplication in the verifier and all mining algorithms. Also, the MakeKey() logic is often implicitly used in the pli_cind and cinderella algorithms and can be replaced by an explicit call to this function.

Oddin60F · 2026-05-03T15:40:44Z

+            entry.values[lhs_cond_size + p.rhs_attr_idx] =
+                    attrs.rhs_conditional[p.rhs_attr_idx]->DecodeValue(p.rhs_value);
+            entry.support = p.support;
+            cover.emplace(key, std::move(entry));


Suggested change

cover.emplace(key, std::move(entry));

cover.emplace(std::move(key), std::move(entry));

Oddin60F · 2026-05-03T15:45:27Z

+    std::vector<Condition> conditions;
+    conditions.reserve(cover.size());
+
+    for (auto& [key, entry] : cover) {


Suggested change

for (auto& [key, entry] : cover) {

for (auto& [_, entry] : cover) {

Oddin60F · 2026-05-03T15:49:41Z

+    std::size_t total_joined = 0;
+    for (auto const& p : patterns) {
+        total_joined += p.support;
+    }


IMHO, it is better to transfer the calculation to the MinimalCover() method since the result is used only there and is not used further.

Oddin60F · 2026-05-03T15:52:26Z

+public:
+    explicit CureCind(config::InputTables& input_tables);
+


Our order of filling in fields in classes is private/protected/public.

Oddin60F · 2026-05-03T16:27:48Z

            .def("get_condition_attributes",
-                 [](CIND const& cind) { return VectorToTuple(cind.conditional_attributes); });
+                 [](CIND const& cind) { return VectorToTuple(cind.conditional_attributes); })
+            .def("get_ind_string", [](CIND const& cind) { return cind.ind.ToLongString(); });


From the point of view of binding requirements (you can look at Wiki/Development‐Features), it would be more correct if the user could get the full IND object embedded in the CIND. You can simply add the get_ind method so that the user can do whatever he wants with the embedded IND.

Please note that due to the fact that the embedded IND is stored by reference in the CIND class, accessing it after destroying the algorithm class will result in an error. It seems worth rewriting the code so that IND is copied or moved to the CIND object.

Oddin60F · 2026-05-03T16:39:19Z

A couple of days ago, a common function appeared in py_util.h for such code. Use it.

Oddin60F · 2026-05-03T16:56:25Z

+TEST_P(TestCureCind, TotalConditions) {
+    auto const& p = GetParam();
+    auto mp = MakeCureParams(p.support);
+    auto cind_algo = algos::CreateAndLoadAlgorithm<algos::cind::CindAlgorithm>(mp);
+    cind_algo->Execute();
+    ASSERT_FALSE(cind_algo->CINDList().empty());
+    size_t total_conditions = 0;
+    for (auto const& cind : cind_algo->CINDList()) {
+        total_conditions += cind.ConditionsNumber();
+    }
+    ASSERT_EQ(total_conditions, p.expected_total_conditions);
+}


It's my mistake that I missed this last time, but it's worth rewriting the tests so that the conditions themselves are checked, too, and not just their number. You can see how it's done, for example, in test_apriori.cpp or test_cfd_algos.cpp

Oddin60F · 2026-05-03T17:51:26Z

+                int const lv = lhs_attr->GetValue(lhs_row);
+                for (std::size_t rhs_row : it->second) {
+                    int const rv = rhs_attr->GetValue(rhs_row);
+                    pair_counts[{lv, rv}]++;


Suggested change

pair_counts[{lv, rv}]++;

++pair_counts[{lv, rv}];

Oddin60F · 2026-05-03T17:53:40Z

+                auto key = MakeKey(lhs_row, attrs.lhs_inclusion);
+                auto it = rhs_index.find(key);


IMHO, it's better this way because we don't need the key anymore.

Suggested change

auto key = MakeKey(lhs_row, attrs.lhs_inclusion);

auto it = rhs_index.find(key);

auto it = rhs_index.find(MakeKey(lhs_row, attrs.lhs_inclusion));

wildsor · 2026-05-05T08:28:17Z

@@ -1,4 +1,6 @@
 set(NAME cind.miners)


This thing wasn't correct, we have at least a target for each algorithm. Make yours a separate one and do some renaming for this one.

Oddin60F · 2026-05-20T21:44:21Z

+        auto* cure = static_cast<CureCind*>(cind_miner_.get());
+        config::Option<unsigned int> support_opt{&cure->min_support_,
+                                                 config::names::kCindMinSupport,
+                                                 config::descriptions::kDCindMinSupport, 2u};
+        support_opt.SetValueCheck([](unsigned int support) {
+            if (support < 1) {
+                throw config::ConfigurationError("ERROR: support must be >= 1.");
+            }
+        });
+        RegisterOption(std::move(support_opt));


For the consistency of the code, it is better to write like this.

Suggested change

auto* cure = static_cast<CureCind*>(cind_miner_.get());

config::Option<unsigned int> support_opt{&cure->min_support_,

config::names::kCindMinSupport,

config::descriptions::kDCindMinSupport, 2u};

support_opt.SetValueCheck([](unsigned int support) {

if (support < 1) {

throw config::ConfigurationError("ERROR: support must be >= 1.");

}

});

RegisterOption(std::move(support_opt));

auto* cure = static_cast<CureCind*>(cind_miner_.get());

auto support_check = [](usnigned int support) {

if(support < 1){

throw config::ConfigurationError("Support must be >= 1.");

}

};

RegisterOption(config::Option<unsigned int>{&cure->min_support_, config::names::kCindMinSupport, config::descriptions::kDCindMinSupport, 2u}.SetValueCheck(std::move(support_check)));

Oddin60F · 2026-05-20T21:59:57Z

+private:
+    friend class CindAlgorithm;
+
+    uint min_support_{2};


uint from sys/types.h is not a standard C++ type and, in theory, its use may lead to compilation errors for other platforms. Just replace it with a standard unsigned int.

Oddin60F · 2026-05-20T23:16:44Z

+    struct CoverEntry {
+        std::vector<std::string> values;
+        std::size_t support{0};
+    };
+
+    using CoverKey = std::pair<std::size_t, int>;
+    std::unordered_map<CoverKey, CoverEntry, PairIntHash> cover;
+
+    std::size_t total_joined = 0;
+    for (PatternPair const& p : patterns) {
+        total_joined += p.support;
+    }
+
+    for (PatternPair const& p : patterns) {
+        CoverKey key{p.lhs_attr_idx, p.lhs_value};
+        auto it = cover.find(key);
+
+        if (it == cover.end()) {
+            CoverEntry entry;
+            entry.values.resize(total_attrs, kAnyValue);
+            entry.values[p.lhs_attr_idx] =
+                    attrs.lhs_conditional[p.lhs_attr_idx]->DecodeValue(p.lhs_value);
+            entry.values[lhs_cond_size + p.rhs_attr_idx] =
+                    attrs.rhs_conditional[p.rhs_attr_idx]->DecodeValue(p.rhs_value);
+            entry.support = p.support;
+            cover.emplace(std::move(key), std::move(entry));
+        } else {
+            CoverEntry& entry = it->second;
+            std::size_t const rhs_pos = lhs_cond_size + p.rhs_attr_idx;
+            std::string const rhs_decoded =
+                    attrs.rhs_conditional[p.rhs_attr_idx]->DecodeValue(p.rhs_value);
+
+            if (entry.values[rhs_pos] == kAnyValue) {
+                entry.values[rhs_pos] = rhs_decoded;
+            } else if (entry.values[rhs_pos].find(rhs_decoded) == std::string::npos) {
+                // Disjunction: append with comma
+                entry.values[rhs_pos] += ", " + rhs_decoded;
+            }
+            entry.support += p.support;
+        }
+    }


It seems like it's more understandable what's going on.

Suggested change

struct CoverEntry {

std::vector<std::string> values;

std::size_t support{0};

};

using CoverKey = std::pair<std::size_t, int>;

std::unordered_map<CoverKey, CoverEntry, PairIntHash> cover;

std::size_t total_joined = 0;

for (PatternPair const& p : patterns) {

total_joined += p.support;

}

for (PatternPair const& p : patterns) {

CoverKey key{p.lhs_attr_idx, p.lhs_value};

auto it = cover.find(key);

if (it == cover.end()) {

CoverEntry entry;

entry.values.resize(total_attrs, kAnyValue);

entry.values[p.lhs_attr_idx] =

attrs.lhs_conditional[p.lhs_attr_idx]->DecodeValue(p.lhs_value);

entry.values[lhs_cond_size + p.rhs_attr_idx] =

attrs.rhs_conditional[p.rhs_attr_idx]->DecodeValue(p.rhs_value);

entry.support = p.support;

cover.emplace(std::move(key), std::move(entry));

} else {

CoverEntry& entry = it->second;

std::size_t const rhs_pos = lhs_cond_size + p.rhs_attr_idx;

std::string const rhs_decoded =

attrs.rhs_conditional[p.rhs_attr_idx]->DecodeValue(p.rhs_value);

if (entry.values[rhs_pos] == kAnyValue) {

entry.values[rhs_pos] = rhs_decoded;

} else if (entry.values[rhs_pos].find(rhs_decoded) == std::string::npos) {

// Disjunction: append with comma

entry.values[rhs_pos] += ", " + rhs_decoded;

}

entry.support += p.support;

}

}

std::size_t total_joined = 0;

for (PatternPair const& p : patterns) {

total_joined += p.support;

}

struct CoverEntry {

std::vector<std::string> values;

std::size_t support{0};

explicit CoverEntry(std::size_t total_attrs): values(total_attrs, kAnyValue) {}

};

using CoverKey = std::pair<std::size_t, int>;

std::unordered_map<CoverKey, CoverEntry, PairIntHash> cover;

for (PatternPair const& p : patterns) {

CoverKey key{p.lhs_attr_idx, p.lhs_value};

auto [it, inserted] = cover.try_emplace(std::move(key), total_attrs);

CoverEntry& entry = it->second;

if (inserted) {

entry.values[p.lhs_attr_idx] =

attrs.lhs_conditional[p.lhs_attr_idx]->DecodeValue(p.lhs_value);

}

std::size_t const rhs_pos = lhs_cond_size + p.rhs_attr_idx;

std::string const rhs_decoded =

attrs.rhs_conditional[p.rhs_attr_idx]->DecodeValue(p.rhs_value);

if (entry.values[rhs_pos] == kAnyValue) {

entry.values[rhs_pos] = rhs_decoded;

} else if (entry.values[rhs_pos].find(rhs_decoded) == std::string::npos) {

// Disjunction: append with comma

entry.values[rhs_pos] += ", " + rhs_decoded;

}

entry.support += p.support;

}

ALanovaya force-pushed the cind/cure-algorithm branch from 2b042d1 to c70be05 Compare April 21, 2026 20:37

wildsor requested changes Apr 29, 2026

View reviewed changes

Comment thread src/core/algorithms/cind/condition_miners/cind_miner.cpp

wildsor requested changes Apr 29, 2026

View reviewed changes

Comment thread src/core/config/CMakeLists.txt Outdated

Comment thread src/core/model/table/encoded_tables.h

ALanovaya force-pushed the cind/cure-algorithm branch 4 times, most recently from b5c081f to 9a57e71 Compare May 2, 2026 18:21

Alexandra Lanovaya added 5 commits May 2, 2026 22:39

Add implementation of Cure algorithm for CIND miner

8fcde1e

fix build for macos

505c44f

fix code style

9c768c4

address review comments

2ef6442

rework cure example, link from cind miner/verifier

24261a0

ALanovaya force-pushed the cind/cure-algorithm branch from 84044db to 24261a0 Compare May 2, 2026 19:40

ALanovaya requested a review from wildsor May 2, 2026 21:09

Oddin60F requested changes May 3, 2026

View reviewed changes

Fix for review

e9265d6

wildsor requested changes May 5, 2026

View reviewed changes

Fix for review

7fb2fe5

ALanovaya requested review from Oddin60F and wildsor May 5, 2026 14:21

wildsor reviewed May 6, 2026

View reviewed changes

Comment thread src/core/algorithms/cind/cind_algorithm.cpp

Alexandra Lanovaya added 2 commits May 7, 2026 12:38

rename examples

4634e9d

make the same changes in shapshot

69f47fd

ALanovaya requested a review from wildsor May 7, 2026 14:48

Oddin60F requested changes May 20, 2026

View reviewed changes

	cover.emplace(key, std::move(entry));
	cover.emplace(std::move(key), std::move(entry));

	for (auto& [key, entry] : cover) {
	for (auto& [_, entry] : cover) {

		public:
		explicit CureCind(config::InputTables& input_tables);

		auto key = MakeKey(lhs_row, attrs.lhs_inclusion);
		auto it = rhs_index.find(key);

	auto key = MakeKey(lhs_row, attrs.lhs_inclusion);
	auto it = rhs_index.find(key);
	auto it = rhs_index.find(MakeKey(lhs_row, attrs.lhs_inclusion));

Conversation

ALanovaya commented Apr 21, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Background

The Cure algorithm

Reference

Changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

ALanovaya commented Apr 21, 2026 •

edited

Loading