io.github.cvc5.SkolemId Maven / Gradle / Ivy
The newest version!
package io.github.cvc5;
import io.github.cvc5.CVC5ApiException;
import java.util.HashMap;
import java.util.Map;
public enum SkolemId
{
/**
* The identifier of the skolem is not exported. These skolems should not
* appear in any user-level API calls.
*/
INTERNAL(0),
/**
* The purification skolem for a term. This is a variable that is semantically
* equivalent to the indexed term t.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The term t that this skolem purifies.
*
*
* - Sort: The sort of t.
*
*/
PURIFY(1),
/**
* An arbitrary ground term of a given sort.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} A term that represents the sort of the term.
*
*
* - Sort: The sort given by the index.
*
*/
GROUND_TERM(2),
/**
* The array diff skolem, which is the witness k for the inference
* {@code (=> (not (= A B)) (not (= (select A k) (select B k))))}.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first array of sort {@code (Array T1 T2)}.
*
* - {@code 2:} The second array of sort {@code (Array T1 T2)}.
*
*
* - Sort: {@code T1}
*
*/
ARRAY_DEQ_DIFF(3),
/**
* The empty bitvector.
*
*
* - Number of skolem indices: {@code 0}
*
* - Type: {@code (_ BitVec 0)}
*
*/
BV_EMPTY(4),
/**
* The function for division by zero. This is semantically equivalent to the
* SMT-LIB term {@code (lambda ((x Real)) (/ x 0.0))}.
*
*
* - Number of skolem indices: {@code 0}
*
* - Sort: {@code (-> Real Real)}
*
*/
DIV_BY_ZERO(5),
/**
* The function for integer division by zero. This is semantically equivalent
* to the SMT-LIB term {@code (lambda ((x Int)) (div x 0))}.
*
*
* - Number of skolem indices: {@code 0}
*
* - Sort: {@code (-> Int Int)}
*
*/
INT_DIV_BY_ZERO(6),
/**
* The function for integer modulus by zero. This is semantically equivalent
* to the SMT-LIB term {@code (lambda ((x Int)) (mod x 0))}.
*
*
* - Number of skolem indices: {@code 0}
*
* - Sort: {@code (-> Int Int)}
*
*/
MOD_BY_ZERO(7),
/**
* A function introduced to eliminate extended trancendental functions.
* Transcendental functions like sqrt, arccos, arcsin, etc. are replaced
* during processing with uninterpreted functions that are unique to
* each function.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} A lambda corresponding to the function, e.g.,
*
*
* `(lambda ((x Real)) (sqrt x))`.
*
* - Sort: {@code (-> Real Real)}
*
*/
TRANSCENDENTAL_PURIFY(8),
/**
* Argument used to purify trancendental function app {@code (f x)}.
* For {@code (sin x)}, this is a variable that is assumed to be in phase with
* {@code x} that is between {@code -pi} and {@code pi}.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The application of a trancendental function.
*
*
* - Sort: {@code Real}
*
*/
TRANSCENDENTAL_PURIFY_ARG(9),
/**
* Argument used to reason about the phase shift of arguments to sine.
* In particular, this is an integral rational indicating the number of times
* \(2\pi\) is added to a real value between \(-\pi\) and \(\pi\)
* to obtain the value of argument to sine.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The argument to sine.
*
*
* - Sort: {@code Real}
*
*/
TRANSCENDENTAL_SINE_PHASE_SHIFT(10),
/**
* A shared datatype selector, see Reynolds et. al. "Datatypes with Shared
* Selectors", IJCAR 2018. Represents a selector that can extract fields
* of multiple constructors.
*
*
* - Number of skolem indices: {@code 3}
*
* - {@code 1:} A term that represents the datatype we are extracting from.
*
* - {@code 2:} A term that represents the sort of field we are extracting.
*
* - {@code 3:} An integer n such that this shared selector returns the n^th
* subfield term of the given sort.
*
*
* - Sort: A selector sort whose domain is given by first index,
* and whose codomain is the given by the second index.
*
*/
SHARED_SELECTOR(11),
/**
* The higher-roder diff skolem, which is the witness k for the inference
* {@code (=> (not (= A B)) (not (= (A k1 ... kn) (B k1 ... kn))))}.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first function of sort {@code (-> T1 ... Tn T)}.
*
* - {@code 2:} The second function of sort {@code (-> T1 ... Tn T)}.
*
* - {@code 3:} The argument index i.
*
*
* - Sort: {@code Ti}
*
*/
HO_DEQ_DIFF(12),
/**
* The n^th skolem for the negation of universally quantified formula Q.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The quantified formula Q.
*
* - {@code 2:} The index of the variable in the binder of Q to skolemize.
*
*
* - Sort: The type of the variable referenced by the second index.
*
*/
QUANTIFIERS_SKOLEMIZE(13),
/**
* An integer corresponding to the number of times a string occurs in another
* string. This is used to reason about str.replace_all.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first string.
*
* - {@code 2:} The second string.
*
*
* - Sort: {@code Int}
*
*/
STRINGS_NUM_OCCUR(14),
/**
* A function k such that for x = 0...n, (k x) is the end
* index of the x^th occurrence of a string b in string a, where n is the
* number of occurrences of b in a, and {@code (= (k 0) 0)}. This is used to
* reason about str.replace_all.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first string.
*
* - {@code 2:} The second string.
*
*
* - Sort: {@code (-> Int Int)}
*
*/
STRINGS_OCCUR_INDEX(15),
/**
* Analogous to STRINGS_NUM_OCCUR, but for regular expressions.
* An integer corresponding to the number of times a regular expression can
* be matched in a string. This is used to reason about str.replace_all_re.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The string to match.
*
* - {@code 2:} The regular expression to find.
*
*
* - Sort: {@code Int}
*
*/
STRINGS_NUM_OCCUR_RE(16),
/**
* Analogous to STRINGS_OCCUR_INDEX, but for regular expressions.
* A function k such that for x = 0...n, (k x) is the end
* index of the x^th occurrence of a regular expression R in string a, where
* n is the number of occurrences of R in a, and {@code (= (k 0) 0)}. This is used
* to reason about str.replace_all_re.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The string to match.
*
* - {@code 2:} The regular expression to find.
*
*
* - Sort: {@code (-> Int Int)}
*
*/
STRINGS_OCCUR_INDEX_RE(17),
/**
* A function k where for x = 0...n, {@code (k x)} is the length of
* the x^th occurrence of R in a (excluding matches of empty strings) where R
* is a regular expression, n is the number of occurrences of R in a, and
* {@code (= (k 0) 0)}.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The string to match.
*
* - {@code 2:} The regular expression to find.
*
*
* - Sort: {@code (-> Int Int)}
*
*/
STRINGS_OCCUR_LEN_RE(18),
/**
* Difference index for string disequalities, such that k is the witness for
* the inference
* {@code (=> (not (= a b)) (not (= (substr a k 1) (substr b k 1))))}
* where note that `k` may be out of bounds for at most of a,b.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first string.
*
* - {@code 2:} The second string.
*
*
* - Sort: {@code Int}
*
*/
STRINGS_DEQ_DIFF(19),
/**
* A function used to define intermediate results of str.replace_all and
* str.replace_re_all applications. This denotes a function that denotes the
* result of processing the string or sequence after processing the n^th
* occurrence of string or match of the regular expression in the given
* replace_all term.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The application of replace_all or replace_all_re.
*
*
* - Sort: {@code (-> Int S)} where S is either {@code String} or {@code (Seq T)} for
*
* some {@code T}.
*/
STRINGS_REPLACE_ALL_RESULT(20),
/**
* A function used to define intermediate results of str.from_int
* applications. This is a function k denoting the result
* of processing the first n digits of the argument.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The argument to str.from_int.
*
*
* - Sort: {@code (-> Int Int)}
*
*/
STRINGS_ITOS_RESULT(21),
/**
* A function used to define intermediate results of str.from_int
* applications. This is a function k of type {@code (-> Int String)} denoting the
* result of processing the first n characters of the argument.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The argument to str.to_int.
*
*
* - Sort: {@code (-> Int String)}
*
*/
STRINGS_STOI_RESULT(22),
/**
* A position containing a non-digit in a string, used when {@code (str.to_int a)}
* is equal to -1. This is an integer that returns a position for which the
* argument string is not a digit if one exists, or is unconstrained otherwise.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The argument to str.to_int.
*
*
* - Sort: {@code Int}
*
*/
STRINGS_STOI_NON_DIGIT(23),
/**
* The next three skolems are used to decompose the match of a regular
* expression in string.
*
* For string a and regular expression R, this skolem is the prefix of
* string a before the first, shortest match of R in a. Formally, if
* {@code (str.in_re a (re.++ (re.* re.allchar) R (re.* re.allchar)))}, then
* there exists strings k_pre, k_match, k_post such that:
* {@code (= a (str.++ k_pre k_match k_post))} and
* {@code (= (len k_pre) (indexof_re a R 0))} and
* ``(forall ((l Int)) (=> (< 0 l (len k_match))
* (not (str.in_re (substr k_match 0 l) R))))`` and
* {@code (str.in_re k_match R)}
* This skolem is k_pre, and the proceeding two skolems are k_match and
* k_post.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The string.
*
* - {@code 2:} The regular expression to match.
*
*
* - Sort: {@code String}
*
*/
RE_FIRST_MATCH_PRE(24),
/**
* For string a and regular expression R, this skolem is the string that
* the first, shortest match of R was matched to in a.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The string.
*
* - {@code 2:} The regular expression to match.
*
*
* - Sort: {@code String}
*
*/
RE_FIRST_MATCH(25),
/**
* For string a and regular expression {@code R}, this skolem is the remainder
* of a after the first, shortest match of {@code R} in a.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The string.
*
* - {@code 2:} The regular expression to match.
*
*
* - Sort: {@code String}
*
*/
RE_FIRST_MATCH_POST(26),
/**
* Regular expression unfold component: if {@code (str.in_re a R)}, where R is
* {@code (re.++ R0 ... Rn)}, then the {@code RE_UNFOLD_POS_COMPONENT} for indices
* (a,R,i) is a string ki such that {@code (= a (str.++ k0 ... kn))} and
* {@code (str.in_re k0 R0)} for i = 0, ..., n.
*
*
* - Number of skolem indices: {@code 3}
*
* - {@code 1:} The string.
*
* - {@code 2:} The regular expression.
*
* - {@code 3:} The index of the skolem.
*
*
* - Sort: {@code String}
*
*/
RE_UNFOLD_POS_COMPONENT(27),
/**
* An uninterpreted function for bag.card operator:
* To compute {@code (bag.card A)}, we need a function that
* counts multiplicities of distinct elements. We call this function
* combine of type Int -> Int where:
* combine(0) = 0.
* combine(i) = m(elements(i), A) + combine(i-1) for 1 <= i <= n.
* elements: a skolem function for (bag.fold f t A).
* See {@code BAGS_DISTINCT_ELEMENTS}.
* n: is the number of distinct elements in A.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag argument A.
*
*
* - Sort: {@code (-> Int Int)}
*
*/
BAGS_CARD_COMBINE(28),
/**
* An uninterpreted function for the union of distinct elements
* in a bag (Bag T). To compute operators like bag.card,
* we need a function for distinct elements in A of type (-> Int T)
* (see {@code BAGS_DISTINCT_ELEMENTS}).
* We also need to restrict the range [1, n] to only elements in the bag
* as follows:
* unionDisjoint(0) = bag.empty.
* unionDisjoint(i) = disjoint union of {<elements(i), m(elements(i), A)>}
* and unionDisjoint(i-1).
* unionDisjoint(n) = A.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag argument A of type (Bag T).
*
*
* - Sort: {@code (-> Int (Bag T))}
*
*/
BAGS_DISTINCT_ELEMENTS_UNION_DISJOINT(29),
/**
* An uninterpreted function for bag.fold operator:
* To compute {@code (bag.fold f t A)}, we need to guess the cardinality n of
* bag A using a skolem function with {@code BAGS_FOLD_CARD} id.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag argument A.
*
*
* - Sort: {@code Int}
*
*/
BAGS_FOLD_CARD(30),
/**
* An uninterpreted function for bag.fold operator:
* To compute {@code (bag.fold f t A)}, we need a function that
* accumulates intermidiate values. We call this function
* combine of type Int -> T2 where:
* combine(0) = t
* combine(i) = f(elements(i), combine(i - 1)) for 1 <= i <= n.
* elements: a skolem function for (bag.fold f t A)
* see {@code BAGS_FOLD_ELEMENTS}.
* n: is the cardinality of A.
* T2: is the type of initial value t.
*
*
* - Number of skolem indices: {@code 3}
*
* - {@code 1:} the function f of type {@code (-> T1 T2)}.
*
* - {@code 2:} the initial value t of type {@code T2}.
*
* - {@code 3:} the bag argument A of type {@code (Bag T1)}.
*
*
* - Sort: {@code (-> Int T2)}
*
*/
BAGS_FOLD_COMBINE(31),
/**
* An uninterpreted function for bag.fold operator:
* To compute {@code (bag.fold f t A)}, we need a function for
* elements of A. We call this function
* elements of type {@code (-> Int T1)} where T1 is the type of
* elements of A.
* If the cardinality of A is n, then
* A is the disjoint union of {elements(i)} for 1 <= i <= n.
* See {@code BAGS_FOLD_UNION_DISJOINT}.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} a bag argument A of type {@code (Bag T1)}
*
*
* - Sort: {@code (-> Int T1)}
*
*/
BAGS_FOLD_ELEMENTS(32),
/**
* An uninterpreted function for bag.fold operator:
* To compute {@code (bag.fold f t A)}, we need a function for
* elements of A which is given by elements defined in
* {@code BAGS_FOLD_ELEMENTS}.
* We also need unionDisjoint: {@code (-> Int (Bag T1))} to compute
* the disjoint union such that:
* unionDisjoint(0) = bag.empty.
* unionDisjoint(i) = disjoint union of {elements(i)} and unionDisjoint (i-1).
* unionDisjoint(n) = A.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag argument A of type {@code (Bag T1)}.
*
*
* - Sort: {@code (-> Int (Bag T1))}
*
*/
BAGS_FOLD_UNION_DISJOINT(33),
/**
* An interpreted function {@code uf} for bag.choose operator:
* {@code (bag.choose A)} is replaced by {@code (uf A)} along with the inference
* that {@code (>= (bag.count (uf A) A) 1)} when {@code A} is non-empty.
* where {@code T} is the type of elements of A.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag to chose from, of type (Bag T).
*
*
* - Sort: {@code (-> (Bag T) T)}
*
*/
BAGS_CHOOSE(34),
/**
* An uninterpreted function for distinct elements of a bag A, which returns
* the n^th distinct element of the bag.
* See {@code BAGS_DISTINCT_ELEMENTS_UNION_DISJOINT}.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag argument A of type {@code (Bag T)}.
*
*
* - Sort: {@code (-> Int T)}
*
*/
BAGS_DISTINCT_ELEMENTS(35),
/**
* A skolem variable for the size of the distinct elements of a bag A.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the bag argument A.
*
*
* - Sort: {@code Int}
*
*/
BAGS_DISTINCT_ELEMENTS_SIZE(36),
/**
* A skolem for the preimage of an element y in {@code (bag.map f A)} such that
* {@code (= (f x) y)} where f: {@code (-> E T)} is an injective function.
*
*
* - Number of skolem indices: {@code 3}
*
* - {@code 1:} the function f of type {@code (-> E T)}.
*
* - {@code 2:} the bag argument A of {@code (Bag E)}.
*
* - {@code 3:} the element argument y type {@code T}.
*
*
* - Sort: {@code E}
*
*/
BAGS_MAP_PREIMAGE_INJECTIVE(37),
/**
* A skolem variable for the index that is unique per terms
* {@code (bag.map f A)}, y, e where:
* f: {@code (-> E T)},
* A: {@code (Bag E)},
* y: {@code T},
* e: {@code E}
*
*
* - Number of skolem indices: {@code 5}
*
* - {@code 1:} a map term of the form {@code (bag.map f A)}.
*
* - {@code 2:} a skolem function with id {@code BAGS_DISTINCT_ELEMENTS}.
*
* - {@code 3:} a skolem function with id {@code BAGS_DISTINCT_ELEMENTS_SIZE}.
*
* - {@code 4:} an element y of type {@code T} representing the mapped value.
*
* - {@code 5:} an element x of type {@code E}.
*
*
* - Sort: {@code Int}
*
*/
BAGS_MAP_INDEX(38),
/**
* An uninterpreted function for bag.map operator:
* If bag A is {uf(1), ..., uf(n)} (see {@code BAGS_DISTINCT_ELEMENTS}},
* then the multiplicity of an element y in a bag {@code (bag.map f A)} is sum(n),
* where sum: {@code (-> Int Int)} is a skolem function such that:
* sum(0) = 0
* sum(i) = sum (i-1) + (bag.count (uf i) A)
*
*
* - Number of skolem indices: {@code 3}
*
* - {@code 1:} the function f of type {@code (-> E T)}.
*
* - {@code 2:} the bag argument A of {@code (Bag E)}.
*
* - {@code 3:} the element argument e type {@code E}.
*
*
* - Sort: {@code (-> Int Int)}
*
*/
BAGS_MAP_SUM(39),
/**
* The bag diff skolem, which is the witness k for the inference
* {@code (=> (not (= A B)) (not (= (bag.count k A) (bag.count k B))))}.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first bag of type {@code (Bag T)}.
*
* - {@code 2:} The second bag of type {@code (Bag T)}.
*
*
* - Sort: {@code T}
*
*/
BAGS_DEQ_DIFF(40),
/**
* Given a group term {@code ((_ table.group n1 ... nk) A)} of type
* {@code (Bag (Table T))}, this skolem maps elements of A to their parts in the
* resulting partition.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} a group term of the form {@code ((_ table.group n1 ... nk) A)}.
*
*
* - Sort: {@code (-> T (Table T))}
*
*/
TABLES_GROUP_PART(41),
/**
* Given a group term {@code ((_ table.group n1 ... nk) A)} of type
* {@code (Bag (Table T))} and a part B of type {@code (Table T)}, this function
* returns a skolem element that is a member of B if B is not empty.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} a group term of the form {@code ((_ table.group n1 ... nk) A)}.
*
* - {@code 2:} a table B of type {@code (Table T)}.
*
*
* - Sort: {@code T}
*
*/
TABLES_GROUP_PART_ELEMENT(42),
/**
* Given a group term {@code ((_ rel.group n1 ... nk) A)} of type
* {@code (Set (Relation T))} this skolem maps elements of A to their parts in the
* resulting partition.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} a relation of the form {@code ((_ rel.group n1 ... nk) A)}.
*
*
* - Sort: {@code (-> T (Relation T))}
*
*/
RELATIONS_GROUP_PART(43),
/**
* Given a group term ((_ rel.group n1 ... nk) A) of type (Set (Relation T))
* and a part B of type (Relation T), this function returns a skolem element
* that is a member of B if B is not empty.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} a group term of the form {@code ((_ rel.group n1 ... nk) A)}.
*
* - {@code 2:} a relation B of type {@code (Relation T)}.
*
*
* - Sort: {@code T}
*
*/
RELATIONS_GROUP_PART_ELEMENT(44),
/**
* An interpreted function for set.choose operator, where {@code (set.choose A)}
* is expanded to {@code (uf A)} along with the inference
* {@code (set.member (uf A) A))} when {@code A} is non-empty,
* where uf: {@code (-> (Set E) E)} is this skolem function, and E is the type of
* elements of {@code A}.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} a ground value for the type {@code (Set E)}.
*
*
* - Sort: {@code (-> (Set E) E)}
*
*/
SETS_CHOOSE(45),
/**
* The set diff skolem, which is the witness k for the inference
* {@code (=> (not (= A B)) (not (= (set.member k A) (set.member k B))))}.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The first set of type {@code (Set E)}.
*
* - {@code 2:} The second set of type {@code (Set E)}.
*
*
* - Sort: {@code E}
*
*/
SETS_DEQ_DIFF(46),
/**
* An uninterpreted function for set.fold operator:
* To compute {@code (set.fold f t A)}, we need to guess the cardinality n of
* set A using a skolem function with SETS_FOLD_CARD id.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} the set argument A.
*
*
* - Sort: {@code Int}
*
*/
SETS_FOLD_CARD(47),
/**
* An uninterpreted function for set.fold operator:
* To compute {@code (set.fold f t A)}, we need a function that
* accumulates intermidiate values. We call this function
* combine of type Int -> T2 where:
* combine(0) = t
* combine(i) = f(elements(i), combine(i - 1)) for 1 <= i <= n
* elements: a skolem function for (set.fold f t A)
* see SETS_FOLD_ELEMENTS
* n: is the cardinality of A
* T2: is the type of initial value t
*
*
* - Number of skolem indices: {@code 3}
*
* - {@code 1:} the function f of type {@code (-> T1 T2)}.
*
* - {@code 2:} the initial value t of type {@code T2}.
*
* - {@code 3:} the set argument A of type {@code (Set T1)}.
*
*
* - Sort: {@code (-> Int T2)}
*
*/
SETS_FOLD_COMBINE(48),
/**
* An uninterpreted function for set.fold operator:
* To compute {@code (set.fold f t A)}, we need a function for
* elements of A. We call this function
* elements of type {@code (-> Int T)} where T is the type of
* elements of A.
* If the cardinality of A is n, then
* A is the union of {elements(i)} for 1 <= i <= n.
* See SETS_FOLD_UNION_DISJOINT.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} a set argument A of type {@code (Set T)}.
*
*
* - Sort: {@code (-> Int T)}
*
*/
SETS_FOLD_ELEMENTS(49),
/**
* An uninterpreted function for set.fold operator:
* To compute {@code (set.fold f t A)}, we need a function for
* elements of A which is given by elements defined in
* SETS_FOLD_ELEMENTS.
* We also need unionFn: {@code (-> Int (Set E))} to compute
* the union such that:
* unionFn(0) = set.empty
* unionFn(i) = union of {elements(i)} and unionFn (i-1)
* unionFn(n) = A
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} a set argument A of type {@code (Set E)}.
*
*
* - Sort: {@code (-> Int (Set E))}
*
*/
SETS_FOLD_UNION(50),
/**
* A skolem variable that is unique per terms {@code (set.map f A)}, y which is an
* element in {@code (set.map f A)}. The skolem is constrained to be an element in
* A, and it is mapped to y by f.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} a map term of the form {@code (set.map f A)} where A of type {@code (Set E)}
*
* - {@code 2:} the element argument y.
*
*
* - Sort: {@code E}
*
*/
SETS_MAP_DOWN_ELEMENT(51),
/**
* A skolem function that is unique per floating-point sort, introduced for
* the undefined zero case of {@code fp.min}.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The floating-point sort {@code FP} of the fp.min operator.
*
*
* - Sort: {@code (-> FP FP (_ BitVec 1))}
*
*/
FP_MIN_ZERO(52),
/**
* A skolem function that is unique per floating-point sort, introduced for
* the undefined zero case of {@code fp.max}.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The floating-point sort {@code FP} of the fp.max operator.
*
*
* - Sort: {@code (-> FP FP (_ BitVec 1))}
*
*/
FP_MAX_ZERO(53),
/**
* A skolem function introduced for the undefined out-ouf-bounds case of
* {@code fp.to_ubv} that is unique per floating-point sort and sort of the
* arguments to the operator.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The floating-point sort {@code FP} of operand of fp.to_ubv.
*
* - {@code 2:} The bit-vector sort {@code BV} to convert to.
*
*
* - Sort: {@code (-> RoundingMode FP BV)}
*
*/
FP_TO_UBV(54),
/**
* A skolem function introduced for the undefined out-ouf-bounds case of
* {@code fp.to_sbv} that is unique per floating-point sort and sort of the
* arguments to the operator.
*
*
* - Number of skolem indices: {@code 2}
*
* - {@code 1:} The floating-point sort {@code FP} of operand of fp.to_sbv.
*
* - {@code 2:} The bit-vector sort {@code BV} to convert to.
*
*
* - Sort: {@code (-> RoundingMode FP BV)}
*
*/
FP_TO_SBV(55),
/**
* A skolem function introduced for the undefined of {@code fp.to_real} that is
* unique per floating-point sort.
*
*
* - Number of skolem indices: {@code 1}
*
* - {@code 1:} The floating-point sort {@code FP} of the operand of fp.to_real.
*
*
* - Sort: {@code (-> FP Real)}
*
*/
FP_TO_REAL(56),
/**
* Indicates this is not a skolem.
*/
NONE(57),
;
/* the int value of the SkolemId */
private int value;
private static int minValue = 0;
private static int maxValue = 0;
private static Map enumMap = new HashMap<>();
private SkolemId(int value)
{
this.value = value;
}
static
{
boolean firstValue = true;
for (SkolemId enumerator : SkolemId.values())
{
int value = enumerator.getValue();
if (firstValue)
{
minValue = value;
maxValue = value;
firstValue = false;
}
minValue = Math.min(minValue, value);
maxValue = Math.max(maxValue, value);
enumMap.put(value, enumerator);
}
}
public static SkolemId fromInt(int value) throws CVC5ApiException
{
if (value < minValue || value > maxValue)
{
throw new CVC5ApiException("SkolemId value " + value + " is outside the valid range ["
+ minValue + "," + maxValue + "]");
}
return enumMap.get(value);
}
public int getValue()
{
return value;
}
}