Duplicated instances in sets - inconsistency with set theory?

[ConstantinVasilev]

When I noticed this initially, I thought it might be a bug but then I saw that it is also included in the documentation under Multiset-semantincs

%%logica Fruit

@Engine("duckdb");

Fruit("apple");
Fruit("apple");
Fruit("orange");

The result of the above code is table with values ["apple", "apple", "orange"]

If Fruit is a predicate defined by 1 arg and we have 2 instances with the same value of this arg, then why these instances aren't considered the same thing and should be duplicated? From predicate point of view these instances are completely undistinguishable.

The set method in Python confirms this:
set({"apple", "apple", "orange"}) -> {'apple', 'orange'}

I guess the goal is to allow for the multiset generalisation but is there an option to revert to standard sets, if someone doesn't want this behaviour?

When working predicate logic it is useful to know that accidental data duplications are not possible since there should be at least one predicate argument which differs between any two instances, and this value explains the difference.

[EvgSkv]

Yes, you are exactly right, non-aggregating predicates define multisets.

As for sets, those are defined by aggregating predicates.

In particular Predicate Level Aggregation says

For our purposes we define set to be a multiset with multiplicity of all occuring rows to be exactly 1. Predicate-level aggregation allows building sets.

For the Fruit example you can use keyword distinct with facts too, but it's more practical to do a follow-up processing.

FruitSet(x) distinct :- Fruit(x);

Please let me know if you have further questions.

[ConstantinVasilev]

Thanks @EvgSkv , I learned something new!

The equivalence to loops from the docs is very interesting, does it have any practical application, e.g. when is it the most efficient way to achieve something?

[EvgSkv]

In practice the data that you work with is often a muliset. Even the input data can have duplicate rows and the duplication has the information. And if your input is guaranteed to be the set, then you still may end up with a multiset as intermediate data.

Of course, mathematics is built on sets and you can encode a multiset as a set, but it is in fact more natural to operate on multisets directly.

Here is an example. We have invited people to a party, for each person we know what fruit they like and what style of cooking they like, so we want to prepare their favorite fruit in their favorite style. All we want to know is how many dishes of each type to cook. Here is a Logica program to calculate it.

Invited("John");
Invited("Anna");
Invited("Jane");

FavoriteFruit("John", "apple");
FavoriteFruit("Anna", "banana");
FavoriteFuite("Jane", "apple");

FavoriteCookingStyle("John", "baked");
FavoriteCookingStyle("Anna", "fried");
FavoriteCookingStyle("Jane", "baked");

RequiredDishRecepie(fruit, style) :-
  Invited(person), FavoriteFruit(person, fruit), FavoriteCookingStyle(person, style);

DishCount(dish_name: style ++ " " ++ fruit, dish_count? += 1) distinct :-
  RequiredDishRecepie(fruit, style);

All the input predicates are sets, but the intermediate predicate RequiredDishRecepie is a multiset. If two people like the same dish, then this predicate will have the duplicate rows. Multisets here allow for consice and intuitive expression of the desired logic.