Stability: [prod] Apt for production use (but please report any bugs).
Usage:project(Sg,Vars,HvFv_u,ASub,Proj)
Proj_gr will the the intersection among Vars and Gv. Proj_sh will be { Xs in Sh | Xs Vars }.
Usage:call_to_entry(Sv,Sg,Hv,Head,K,Fv,Proj,Entry,ExtraInfo)
It obtains the abstract substitution (Entry) which results from adding the abstraction of the Sg = Head to Proj, later projecting the resulting substitution onto Hv. This is done as follows:
Usage:exit_to_prime(Sg,Hv,Head,Arg4,Exit,ExtraInfo,Prime)
Usage:abs_sort(ASub_u,ASub)
First sorts the set of variables in Gr, then it sorts the set of set of variables Sh.
Usage:compute_lub(ListASub,Lub)
It computes the lub of a set of Asub. For each two abstract substitutions ASub1 and ASub2 in ListASub, obtaining the lub is just
Usage:glb(ASub0,ASub1,Lub)
Usage:extend(Sg,Prime,Sv,Call,Succ)
If Prime = bottom, Succ = bottom. If Sv = [], Call = Succ. Otherwise:
Usage:
Specialized version of call_to_entry + exit_to_prime + extend for facts
Usage:
Obtains the abstract prime substitution from the lambda for a fact. (it is a combination of the call_to_entry and exit_to_prime functions) only needed in the combinations of domains.
Usage:unknown_call(Sg,Vars,Call,Succ)
Succ_gr is identical to Call_gr. Succ_sh is obtained by selecting the non ground variables in Vars, and obtaining all possible couples and singletons.
Usage:unknown_entry(Sg,Qv,Call)
The top value in Sh for a set of variables is the powerset, in Fr is X/nf forall X in the set of variables.
Usage:
The empty value in Sh for a set of variables is the list of singletons, in Fr is X/f forall X in the set of variables. So, here, all linear and independent: i.e., [].
Usage:asub_to_native(ASub,Qv,OutFlag,ASub_user,Comps)
The user friendly format consists in extracting the ground variables (Gr) the linear variables (those which do not appear as singletons in Sh). The rest is the way in which pair sharing is transformed into set sharing
Usage:input_user_interface(InputUser,Qv,ASub,Sg,MaybeCallASub)
Gr is the set of variables which are in Qv but not in Sharing (share(Sharing) given by the user). Sh is computed as follows:
Usage:special_builtin(SgKey,Sg,Subgoal,Type,Condvars)
Satisfied if the builtin does not need a very complex action. It divides builtins into groups determined by the flag returned in the second argument + some special handling for some builtins:
Usage:success_builtin(Type,Sv_u,Condv,_HvFv_u,Call,Succ)
Obtains the success for some particular builtins:
Usage:call_to_success_builtin(SgKey,Sg,Sv,Call,Proj,Succ)
If it gets here, the call for the builtin is bound to fail, so ...
Usage:propagate_to_sh(ASub_sh,SSon,NewASub_sh,Allowed_sh)
Eliminates the redundancies in ASub_sh using SSon. This is done by for each set Xs in ASub_sh:
Usage:propagate_to_son(SSon,Allowed_sh,NewGSon,NewSSon)
Eliminates the redundancies in SSon using Allowed_sh and NewGSon. This is done by for each set Xs in SSon: