Operators - Prometheux

Vadalog supports built-in operations over values of data types. These operations allow to compare values, perform arithmetics, manipulate strings and datetime values. Operations are supported through symbolic operators, which can be prefix, infix or functional-style. Vadalog supports single-fact operators (simply called operators) and multi-facts operators (called aggregation operators).

Single-fact operators

Data type	Operators
all	`==`, `>`, `<`, `>=`, `<=`, `<>`, `!=`
integer	(monadic) `-`, `*`, `/`, `+`, `-`, `( )`
double	(monadic) `-`, `*`, `/`, `+`, `-`, `( )`
boolean	`&&`, `\|\|`, `!`, `not`, `( )` for associativity
string	`substring`, `contains`, `contains_any`, `rlike`, `starts_with`, `ends_with`, `concat`, `concat_ws`, `replace`, `join`, `index_of`, `string_length` (alias `strlen`), `to_lower`, `to_upper`, `split`, `is_empty`, `strip`
similarity	`similarity:levenshtein`, `similarity:levenshtein_sim`, `similarity:jaro_winkler`, `similarity:jaccard`
set	`\|` (union), `&` (intersection), `( )` for associativity

Comparison operators

The comparison operators are ==,>,<,>=,<=,<> (alternate syntax !=). They can be used to compare literals of any data type and return a Boolean, depending whether the comparison is satisfied or not. Only values of the same type can be compared.

== : equals to
> : greater than
< : less than
>= : greater or equal
<= : less or equal
<> : not equal
!= : not equal

Marked nulls can be compared only with marked nulls, since they are the only ones having unknown data type. Marked nulls are equal when they have the same identifier (i.e. they are the same marked null).

Arithmetic operators

The arithmetic operators are * (multiplication), / (division), + (addition), - (subtraction). Infix *, /, +, - can be applied to all numeric (integer and double) operands, with an implicit upcast to double if any double is involved. The operator + (plus) also performs string concatenation with an implicit upcast to string if any string is involved. The operator - (minus) also exists in its monadic version, which simply inverts the sign of a numeric value. Division by 0 always fails, causing the program to abort. Operations associate to the left, except that multiplication and division operators have higher precedence than addition and subtraction operators. Precedence can be altered with parentheses.

Boolean operators

The Boolean operators are and (&&), or (||) or not. They can be used to combine Boolean data types.

Logical operators

Vadalog supports explicit logical operators as functions in addition to implicit logical operations through rule structure. These explicit operators (and(), or(), not(), etc.) allow for combining and manipulating Boolean expressions within a single rule. The operators can evaluate complex logical conditions and can be assigned to variables for further processing. Key distinction:

Implicit AND/OR: Multiple conditions in a rule body are implicitly AND-ed. Multiple rules with the same head represent OR.
Explicit operators: Functions like and(), or(), not(), xor(), if() allow complex boolean logic within expressions and can be assigned to variables.

Available explicit logical operators:

and(args) - Logical AND of multiple conditions
or(args) - Logical OR of multiple conditions
not(expression) - Logical NOT/negation
xor(expression1, expression2) - Exclusive OR
nand(expression1, expression2) - NOT AND
nor(expression1, expression2) - NOT OR
xnor(expression1, expression2) - Exclusive NOR
implies(expression1, expression2) - Logical implication
iff(expression1, expression2) - If and only if
if(condition, true_value, false_value) - Conditional expression

`and(args)`

The and(args) operator evaluates to true if all the conditions in args are true. You can assign the result to a variable and use ==#T to enforce that all conditions must be true. Example 1: Basic and(args) usage This example shows the use of the and(args) operator to evaluate multiple conditions on the variable X. The rule b(X, IsIn) checks if X is greater than 2, less than 5, and equal to 3. The result of this conjunction is stored in IsIn.

@output("b").
a(1).
a(2).
a(3).
a(4).
a(5).
b(X, IsIn) <- a(X), IsIn=and(X>2, X<5, X==3).

Expected output:

b(1, #F).
b(2, #F).
b(3, #T).
b(4, #F).
b(5, #F).

`or(args)`

The or(args) operator evaluates to true if any of the conditions in args are true. You can assign the result to a variable and use ==#T to enforce that at least one condition must be true. Example 2: Basic or(args) usage This example illustrates the use of the or(args) operator to evaluate multiple conditions on the variable X. The rule b(X, IsIn) checks if X is less than 2, equal to 4, or equal to 6. The result of this disjunction is stored in IsIn.

@output("b").
a(1).
a(2).
a(3).
a(4).
a(5).
b(X, IsIn) <- a(X), IsIn=or(X<2, X==4, X==6).

Expected output:

b(1, #T).
b(2, #F).
b(3, #F).
b(4, #T).
b(5, #F).

`not(expression)`

The not(expression) operator negates the Boolean value of the expression. It returns #T if the expression is #F, and #F if the expression is #T. Example 3: Basic not(expression) usage This example demonstrates the use of the not operator to negate a condition.

@output("b").
a(1).
a(2).
a(3).
b(X, IsNotTwo) <- a(X), IsNotTwo=not(X==2).

Expected output:

b(1, #T).
b(2, #F).
b(3, #T).

`xor(expression1, expression2)`

The xor(expression1, expression2) operator (exclusive or) evaluates to true if exactly one of the two expressions is true, but not both. Example 4: Basic xor(expression1, expression2) usage This example shows the exclusive or operation between two conditions.

@output("b").
a(1).
a(2).
a(3).
b(X, IsExclusive) <- a(X), IsExclusive=xor(X>1, X<3).

Expected output:

b(1, #F).
b(2, #F).
b(3, #T).

`nand(expression1, expression2)`

The nand(expression1, expression2) operator (not and) evaluates to true if at least one of the expressions is false. Example 5: Basic nand(expression1, expression2) usage This example demonstrates the NAND operation.

@output("b").
a(1).
a(2).
a(3).
b(X, IsNand) <- a(X), IsNand=nand(X>1, X<3).

Expected output:

b(1, #T).
b(2, #F).
b(3, #T).

`nor(expression1, expression2)`

The nor(expression1, expression2) operator (not or) evaluates to true only if both expressions are false. Example 6: Basic nor(expression1, expression2) usage This example demonstrates the NOR operation.

@output("b").
a(1).
a(2).
a(3).
b(X, IsNor) <- a(X), IsNor=nor(X>1, X<3).

Expected output:

b(1, #F).
b(2, #F).
b(3, #F).

`xnor(expression1, expression2)`

The xnor(expression1, expression2) operator (exclusive nor) evaluates to true if both expressions have the same Boolean value. Example 7: Basic xnor(expression1, expression2) usage This example demonstrates the XNOR operation.

@output("b").
a(1).
a(2).
a(3).
b(X, IsXnor) <- a(X), IsXnor=xnor(X>1, X<3).

Expected output:

b(1, #T).
b(2, #T).
b(3, #F).

`implies(expression1, expression2)`

The implies(expression1, expression2) operator (implication) evaluates to false only if the first expression is true and the second is false. Example 8: Basic implies(expression1, expression2) usage This example demonstrates logical implication.

@output("b").
a(1).
a(2).
a(3).
b(X, IsImplied) <- a(X), IsImplied=implies(X>1, X<3).

Expected output:

b(1, #T).
b(2, #T).
b(3, #F).

`iff(expression1, expression2)`

The iff(expression1, expression2) operator (if and only if) evaluates to true if both expressions have the same Boolean value. Example 9: Basic iff(expression1, expression2) usage This example demonstrates the if and only if operation.

@output("b").
a(1).
a(2).
a(3).
b(X, IsIff) <- a(X), IsIff=iff(X>1, X<3).

Expected output:

b(1, #T).
b(2, #T).
b(3, #F).

`if(condition, true_value, false_value)`

The if(condition, true_value, false_value) operator provides conditional logic. It returns true_value if the condition is true, otherwise it returns false_value. Example 10: Basic if(condition, true_value, false_value) usage This example demonstrates conditional logic using the if operator to classify numbers as positive or non-positive.

@output("b").
a(1).
a(-1).
b(Result, Value) <- a(Value), GTZero=Value>0, Result=if(GTZero, "positive", "non-positive").

Expected output:

b("positive", 1).
b("non-positive", -1).

Example 11: String condition with if operator This example uses the if operator to check if a string is empty and return appropriate labels.

@output("b").
a("").
a("NonEmpty").
a(" ").
b(El, IsEmpty) <- a(El), IsEmpty=if(is_empty(El), "is_empty", "is_not_empty").

Expected output:

b("", "is_empty").
b("NonEmpty", "is_not_empty").
b(" ", "is_not_empty").

Example 12: Null check with if operator This example uses the if operator to check if a string is not null and return appropriate labels.

@output("b").
a("hello").
a("not_null").
b(El, State) <- a(El), State=if(is_not_null(El), "not_null", "is_null").

Expected output:

b("hello", "not_null").
b("not_null", "not_null").

Example 13: Nested if statements for credit rating This example demonstrates complex nested if statements to implement a credit rating system based on credit scores. Each nested if evaluates a range of credit scores and assigns a corresponding rating value.

@output("credit_rating").
credit_score(450.0).
credit_score(580.0).
credit_score(720.0).
credit_score(780.0).
credit_score(820.0).
credit_score(850.0).
credit_score(920.0).

credit_rating(Val) <- credit_score(Score), Val = if(Score < 500.0, -3.250,
                                                    if(and(Score >= 500.0, Score < 600.0), -2.150,
                                                    if(and(Score >= 600.0, Score < 700.0), -1.200,
                                                    if(and(Score >= 700.0, Score < 750.0), -0.500,
                                                    if(and(Score >= 750.0, Score < 800.0), 0.250,
                                                    if(and(Score >= 800.0, Score < 850.0), 0.750,
                                                    if(and(Score >= 850.0, Score < 900.0), 1.200,
                                                    if(and(Score >= 900.0, Score < 950.0), 1.650,
                                                    if(and(Score >= 950.0, Score < 1000.0), 2.100,
                                                    if(and(Score >= 1000.0, Score < 1100.0), 2.550, 
                                                                                            3.000)))))))))).

Expected output:

credit_rating(-3.250).
credit_rating(-2.150).
credit_rating(-1.200).
credit_rating(-0.500).
credit_rating(0.250).
credit_rating(0.750).
credit_rating(1.200).

Example 14: Using and(args) with condition enforcement In this example, the and(args) operator is used to evaluate conditions on X, and the result is compared to #T to enforce that all conditions must be true. The rule b(X) only succeeds if X is greater than 2, less than 5, and equal to 3.

@output("b").
a(1).
a(2).
a(3).
a(4).
a(5).
b(X) <- a(X), IsIn=and(X>2, X<5, X==3), IsIn==#T.

Expected output:

b(3).

String operators

The String operators are substring, contains, contains_any, rlike, starts_with, ends_with, concat, concat_ws, +, index_of, string_length, to_lower, to_upper, split, replace, join, is_empty, and strip. These operators allow manipulation and comparison of String values.

`substring`

A rule using substring returns a substring from the specified start to end index, using zero-based indexing:

q(K1, K2, Kn, J) <- body, J = substring(x, start, end).

Example:

showLineNumbers

a("prometheux").
b("oxford").
q(Y,J) <- a(X), b(Y), J = substring(X,4,10).
@output("q").

Expected output:

q("oxford", "metheux").

`contains`

A rule with contains returns true if the string contains substring:

q(K1, K2, Kn, J) <- body, J = contains(string, substring).

Example:

showLineNumbers

a("prometheux engine").
b("engine").
q(X, Y, J) <- a(X), b(Y), J = contains(X, Y).
@output("q").

Expected output:

q("prometheux engine", "engine", #T).

contains can also be used directly as a boolean condition in the rule body (see Implicit Boolean Conditions).

`starts_with`

A rule with starts_with returns true if the string starts with start_string:

q(K1, K2, Kn, J) <- body, J = starts_with(string, start_string).

Example:

showLineNumbers

a("prometheux").
b("prom").
q(X,Y,J) <- a(X), b(Y), J = starts_with(X,Y).
@output("q").

Expected output:

q("prometheux", "prom", #T).

`ends_with`

A rule with ends_with returns true if the string ends with end_string:

q(K1, K2, Kn, J) <- body, J = ends_with(string, end_string).

Example:

showLineNumbers

a("prometheux").
b("theux").
q(X, Y, J) <- a(X), b(Y), J = ends_with(X,Y).
@output("q").

Expected output:

q("prometheux", "theux", #T).

`contains_any`

A rule with contains_any returns true if the string contains any of the keywords in the keywords_array:

q(K1, K2, Kn, J) <- body, J = contains_any(string, keywords_array).

Example:

showLineNumbers

a("hello world", ["world", "foo"]).
b("hello world", ["bar", "baz"]).
c(Result) <- a(Text, Keywords), Result = contains_any(Text, Keywords).
d(Result) <- b(Text, Keywords), Result = contains_any(Text, Keywords).
@output("c").
@output("d").

Expected output:

c(#T).
d(#F).

`rlike`

A rule with rlike returns true if the string matches the given regular expression pattern:

q(K1, K2, Kn, J) <- body, J = rlike(string, pattern).

Example:

showLineNumbers

a("foo bar").
a("the foobar case").
keyword("foo").
b(Name, Matches) <- a(Name), keyword(K), Matches = rlike(Name, concat("(^| )", K, "( |$)")).
@output("b").

Expected output:

b("foo bar", #T).
b("the foobar case", #F).

`concat`

A rule with concat returns the concatenation of string and concat_string:

q(K1, K2, Kn, J) <- body, J = concat(string, concat_string).

Example:

showLineNumbers

a("prometheux").
b("engine").
q(X,Y,J) <- a(X), b(Y), J = concat(X,Y).
@output("q").

Expected output:

q("prometheux", "engine", "prometheuxengine").

`string_length`

A rule with string_length returns an integer representing the length of the string. strlen is an accepted alias:

q(K1, K2, Kn, J) <- body, J = string_length(string).
q(K1, K2, Kn, J) <- body, J = strlen(string).          % equivalent alias

Example:

showLineNumbers

a("prometheux").
q(X, J) <- a(X), J = string_length(X).
@output("q").

Expected output:

q("prometheux", 10).

`to_lower`

A rule with to_lower converts string to lowercase:

q(K1, K2, Kn, J) <- body, J = to_lower(string).

Example:

showLineNumbers

a("Prometheux").
q(X, J) <- a(X), J = to_lower(X).
@output("q").

Expected output:

q("Prometheux", "prometheux").

`to_upper`

A rule with to_upper converts string to uppercase:

q(K1, K2, Kn, J) <- body, J = to_upper(string).

Example:

showLineNumbers

a("prometheux").
q(X, J) <- a(X), J = to_upper(X).
@output("q").

Expected output:

q("prometheux", "PROMETHEUX").

`split`

A rule with split divides string by a specified delimiter, producing a list of substrings:

q(K1, K2, Kn, J) <- body, J = split(string, delimiter).

Example:

showLineNumbers

a("prometheux engine").
q(X, J) <- a(X), J = split(X, " ").
@output("q").

Expected output:

q("prometheux engine", ["prometheux", "engine"]).

`index_of`

A rule with index_of finds the index of substring within string, returning -1 if not found:

q(K1, K2, Kn, J) <- body, J = index_of(string, substring).

Example:

showLineNumbers

a("prometheux").
b("theux").
q(X, Y, J) <- a(X), b(Y), J = index_of(X,Y).
@output("q").

Expected output:

q("prometheux", "theux", 4).

`substring` (single parameter)

You can also use substring with a single parameter to get the substring from a starting position to the end:

q(K1, K2, Kn, J) <- body, J = substring(string, start).

Example:

showLineNumbers

a("Elizabeth").
b(Name, Substring) <- a(Name), Substring = substring(Name, 6).
@output("b").

Expected output:

b("Elizabeth", "beth").

`concat_ws`

A rule with concat_ws concatenates strings with a specified separator:

q(K1, K2, Kn, J) <- body, J = concat_ws(separator, string1, string2, ...).

Example:

showLineNumbers

a("Laura", "Wilson").
b(FirstName, LastName, FullName) <- a(FirstName, LastName), FullName = concat_ws(" ", FirstName, LastName).
@output("b").

Expected output:

b("Laura", "Wilson", "Laura Wilson").

`replace`

A rule with replace replaces occurrences of a substring with another string:

q(K1, K2, Kn, J) <- body, J = replace(string, search, replacement).

Example:

showLineNumbers

a("The quick brown fox").
b(Result) <- a(Input), Result = replace(Input, "fox", "dog").
@output("b").

Expected output:

b("The quick brown dog").

`join`

A rule with join joins array elements into a string with a specified delimiter:

q(K1, K2, Kn, J) <- body, J = join(array, delimiter).

Example:

showLineNumbers

a(["apple", "banana", "cherry"]).
b(JoinedString) <- a(Array), JoinedString = join(Array, ";").
@output("b").

Expected output:

b("apple;banana;cherry").

`is_empty`

A rule with is_empty checks if a string is empty or contains only whitespace:

q(K1, K2, Kn, J) <- body, J = is_empty(string).

Example:

showLineNumbers

a("").
a("NonEmpty").
a(" ").
b(El, IsEmpty) <- a(El), IsEmpty = is_empty(El).
@output("b").

Expected output:

b("", #T).
b("NonEmpty", #F).
b(" ", #T).

`strip`

A rule with strip removes leading and trailing whitespace from a string:

q(K1, K2, Kn, J) <- body, J = strip(string).

Example:

showLineNumbers

a("  hello world  ").
a("no_spaces").
b(Original, Stripped) <- a(Original), Stripped = strip(Original).
@output("b").

Expected output:

b("  hello world  ", "hello world").
b("no_spaces", "no_spaces").

Similarity operators

The similarity operators measure how close two strings are, which is useful for fuzzy matching, deduplication, and entity resolution. They live in the similarity: namespace.

Operator	Returns	Range	Best for
`similarity:levenshtein`	`integer`	`0` and up	Raw edit distance (typos, codes, identifiers)
`similarity:levenshtein_sim`	`double`	`[0.0, 1.0]`	Normalized edit similarity
`similarity:jaro_winkler`	`double`	`[0.0, 1.0]`	Short strings such as person or company names
`similarity:jaccard`	`double`	`[0.0, 1.0]`	Multi-word text where word order does not matter
`similarity:cosine_sim`	`double`	`[-1.0, 1.0]`	Numeric vectors / embeddings (arrays of doubles)
`similarity:cosine_sim_udf`	`double`	`[-1.0, 1.0]`	Same as `cosine_sim`, computed via a UDF

For the string operators _sim/jaro_winkler/jaccard, 1.0 means identical and 0.0 means completely different. The cosine_sim operators instead operate on numeric vectors (array<double>), typically embeddings produced by embeddings:vectorize — see AI functions.

`similarity:levenshtein`

A rule with similarity:levenshtein returns the edit distance between two strings: the minimum number of single-character insertions, deletions, or substitutions needed to turn one into the other (0 means identical).

q(K1, K2, Kn, J) <- body, J = similarity:levenshtein(string1, string2).

Example:

showLineNumbers

a("kitten", "sitting").
b(Distance) <- a(Left, Right), Distance = similarity:levenshtein(Left, Right).
@output("b").

Expected output:

b(3).

`similarity:levenshtein_sim`

A rule with similarity:levenshtein_sim returns the normalized edit similarity, computed as 1 - distance / max(length). Two empty strings are defined as fully similar (1.0).

q(K1, K2, Kn, J) <- body, J = similarity:levenshtein_sim(string1, string2).

Example:

showLineNumbers

a("kitten", "sitting").
b(Similarity) <- a(Left, Right), Similarity = similarity:levenshtein_sim(Left, Right).
@output("b").

Expected output:

b(0.5714285714285714).

`similarity:jaro_winkler`

A rule with similarity:jaro_winkler returns the Jaro-Winkler similarity, which boosts the score of strings sharing a common prefix. This makes it well suited to matching short strings such as person or company names.

q(K1, K2, Kn, J) <- body, J = similarity:jaro_winkler(string1, string2).

Example:

showLineNumbers

a("MARTHA", "MARHTA").
b(Similarity) <- a(Left, Right), Similarity = similarity:jaro_winkler(Left, Right).
@output("b").

Expected output:

b(0.9611111111111111).

`similarity:jaccard`

A rule with similarity:jaccard treats each string as the set of its whitespace-delimited tokens and returns the size of their intersection divided by the size of their union. Two empty token sets are defined as fully similar (1.0).

q(K1, K2, Kn, J) <- body, J = similarity:jaccard(string1, string2).

Example:

showLineNumbers

a("apple banana cherry", "banana cherry date").
b(Similarity) <- a(Left, Right), Similarity = similarity:jaccard(Left, Right).
@output("b").

Expected output:

b(0.5).

`similarity:cosine_sim`

A rule with similarity:cosine_sim returns the cosine similarity between two numeric vectors (arrays of doubles), such as embeddings. similarity:cosine_sim_udf computes the same value via a UDF. See AI functions for generating embeddings with embeddings:vectorize.

q(K1, K2, Kn, J) <- body, J = similarity:cosine_sim(vector1, vector2).

Example:

showLineNumbers

a([0.1, 0.2, 0.3], [0.5, 0.2, 0.5]).
b(Score) <- a(Vec1, Vec2), Score = similarity:cosine_sim(Vec1, Vec2).
@output("b").

Set operators

Vadalog supports set operations on arrays using the union (|) and intersection (&) operators.

Union (`|`)

The union operator combines two arrays, removing duplicates:

showLineNumbers

a([1, 2, 3], 4).
b(Result) <- a(Set1, Value), Result = Set1 | Value.
@output("b").

Expected output:

b([4, 1, 2, 3]).

Intersection (`&`)

The intersection operator finds common elements between two arrays:

showLineNumbers

a([1, 2, 3], [2, 3, 4]).
b(Result) <- a(Set1, Set2), Result = Set1 & Set2.
@output("b").

Expected output:

b([2, 3]).

Implicit Boolean Conditions

Boolean-returning functions can be used directly as conditions in rule bodies without explicit comparison to #T. This provides a more natural syntax for filtering.

Direct Boolean Functions as Conditions

showLineNumbers

a(1, "Alice").
a(2, "Bob").
out(X) <- a(X, Y), contains(Y, "Alice").
@output("out").

Expected output:

out(1).

Negated Boolean Conditions with `!`

Use ! to negate boolean expressions directly in conditions:

showLineNumbers

a(1, "Alice").
a(2, "Bob").
out(X) <- a(X, Y), !contains(Y, "Alice").
@output("out").

Expected output:

out(2).

Distinction: `not` vs `!`

not: Used for negating atoms (checking if a predicate doesn’t exist)
!: Used for negating boolean expressions

showLineNumbers

person(1, "Alice").
person(2, "Bob").
blocked(2).
activeAlice(ID, Name) <- person(ID, Name), not blocked(ID), starts_with(Name, "Ali").
activeNonAlice(ID, Name) <- person(ID, Name), not blocked(ID), !starts_with(Name, "Ali").
@output("activeAlice").
@output("activeNonAlice").

Expected output:

activeAlice(1, "Alice").

Note: Bob is blocked, so doesn’t appear in either output.

​Single-fact operators

​Comparison operators

​Arithmetic operators

​Boolean operators

​Logical operators

​and(args)

​or(args)

​not(expression)

​xor(expression1, expression2)

​nand(expression1, expression2)

​nor(expression1, expression2)

​xnor(expression1, expression2)

​implies(expression1, expression2)

​iff(expression1, expression2)

​if(condition, true_value, false_value)

​String operators

​substring

​contains

​starts_with

​ends_with

​contains_any

​rlike

​concat

​string_length

​to_lower

​to_upper

​split

​index_of

​substring (single parameter)

​concat_ws

​replace

​join

​is_empty

​strip

​Similarity operators

​similarity:levenshtein

​similarity:levenshtein_sim

​similarity:jaro_winkler

​similarity:jaccard

​similarity:cosine_sim

​Set operators

​Union (|)

​Intersection (&)

​Implicit Boolean Conditions

​Direct Boolean Functions as Conditions

​Negated Boolean Conditions with !

​Distinction: not vs !

Single-fact operators

Comparison operators

Arithmetic operators

Boolean operators

Logical operators

`and(args)`

`or(args)`

`not(expression)`

`xor(expression1, expression2)`

`nand(expression1, expression2)`

`nor(expression1, expression2)`

`xnor(expression1, expression2)`

`implies(expression1, expression2)`

`iff(expression1, expression2)`

`if(condition, true_value, false_value)`

String operators

`substring`

`contains`

`starts_with`

`ends_with`

`contains_any`

`rlike`

`concat`

`string_length`

`to_lower`

`to_upper`

`split`

`index_of`

`substring` (single parameter)

`concat_ws`

`replace`

`join`

`is_empty`

`strip`

Similarity operators

`similarity:levenshtein`

`similarity:levenshtein_sim`

`similarity:jaro_winkler`

`similarity:jaccard`

`similarity:cosine_sim`

Set operators

Union (`|`)

Intersection (`&`)

Implicit Boolean Conditions

Direct Boolean Functions as Conditions

Negated Boolean Conditions with `!`

Distinction: `not` vs `!`