package lambdapi
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=d01e5f13db2eaba6e4fe330667149e0059d4886c651ff9d6b672db2dfc9765ed
sha512=33b68c972aca37985ed73c527076198e7d4961c7e27c89cdabfe4d1cff97cd41ccfb85ae9499eb98ad9a0aefd920bc55555df6393fc441ac2429e4d99cddafa8
doc/lambdapi.tool/Tool/Lcr/index.html
Module Tool.Lcr
Source
Incremental verification of local confluence
by checking the joinability of critical pairs.
- CP(l-->r, p, g-->d) =
(s(r), s(l[d]_p) | s = mgu(l|_p,g)
is the critical pair between l|_p and g.
- CP*(l-->r, g-->d) = U
CP(l-->r, p, g-->d) | p in FPos(l)
- CP*(R,S) = U
CP*(l-->r, g-->d) | l-->r in R, g-->d in S
The set of critical pairs of a rewrite system R is CP(R) = CP*(R,R).
We have CP(R U S) = CP*(R,R) U CP*(R,S) U CP*(S,R) U CP*(S,S).
As a consequence, assuming that we already checked the local confluence of R and add a new set S of rules, we do not need to check CP*(R,R) again.
Warning: we currently do not take into account the rules having higher-order pattern variables and critical pairs on AC symbols.
Remark: When trying to unify a subterm of a rule LHS with the LHS of another rule, we need to rename the pattern variables of one of the LHS to avoid name clashes. To this end, we use the shift
function below which replaces Patt(i,n,_)
by Patt(-i-1,n ^ "'",_)
. The printing function subs
below takes this into account.
rule_of_pair ppf x
prints on ppf
the pair of term x
as a rule.
is_ho r
says if r
uses higher-order variables.
is_definable s
says if s
is definable and non opaque.
rule_of_def s d
creates the rule s --> d
.
replace t p u
replaces the subterm of t
at position p
by u
.
occurs i t
returns true
iff Patt(i,_,_)
is a subterm of t
.
shift t
replaces in t
every pattern index i by -i-1.
Type for pattern variable substitutions.
apply_subs s t
applies the pattern substitution s
to t
.
type iter =
Common.Pos.popt ->
(Core.Term.sym -> Core.Term.subterm_pos -> Core.Term.term -> unit) ->
Core.Term.term ->
unit
Type of subterm iterators.
iter_subterms_eq pos f p t
iterates f on all subterms of t
headed by a defined function symbol. p
is the position of t
in reverse order.
iter_subterms_eq pos f t
iterates f on all subterms of t
headed by a defined function symbol.
iter_subterms pos f t
iterates f on all strict subterms of t
headed by a defined function symbol.
val unif :
Common.Pos.popt ->
Core.Term.term ->
Core.Term.term ->
Core.Term.term Lplib.Extra.IntMap.t option
unif pos t u
returns None
if t
and u
are not unifiable, and Some s
with s
an idempotent mgu otherwise. Precondition: l
and r
must have distinct indexes in Patt subterms.
can_handle sr
says if the sym_rule sr
can be handled.
iter_rules h rs
iterates function f
on every rule of rs
.
iter_sym_rules h rs
iterates function f
on every rule of rs
.
iter_rules_of_sym h s
iterates f
on every rule of s
.
Type of rule identifiers. Hack: we use the rule position to distinguish between user-defined and generated rules (in completion), by giving a unique negative start_line to every generated rule.
id_sym_rule r
returns the rule id of r
.
int_of_rule_id i
returns a unique integer from i
. /!\ i
must be a generated rule.
type cp_fun =
Common.Pos.popt ->
rule_id ->
Core.Term.term ->
Core.Term.term ->
Core.Term.subterm_pos ->
Core.Term.term ->
rule_id ->
Core.Term.term ->
Core.Term.term ->
subs ->
unit
Type of functions on critical pairs.
type cp_cand_fun =
Common.Pos.popt ->
rule_id ->
Core.Term.term ->
Core.Term.term ->
Core.Term.subterm_pos ->
Core.Term.term ->
rule_id ->
Core.Term.term ->
Core.Term.term ->
unit
Type of functions on critical pair candidates.
cp_cand_fun
turns a cp_fun into a cp_cand_fun.
val iter_cps_with_rule :
iter ->
cp_fun ->
Common.Pos.popt ->
Core.Term.sym_rule ->
Core.Term.sym_rule ->
unit
iter_cps_with_rule iter_subterms h pos sr1 sr2
applies h
on all the critical pairs between all the subterms of the sr1
LHS and the sr2
LHS using the iterator iter_subterms
.
iter_cps_of_rules h pos rs
applies h
on all the critical pairs of rs
with itself.
typability_constraints pos t
returns None
if t
is not typable, and Some s
where s
is a substitution implied by the typability of t
.
check_cp pos _ l r p l_p _ g d s
checks that, if l_p
and g
are unifiable with mgu s
, then s(r)
and s(l[d]_p)
are joinable. Precondition: l
and r
must have distinct indexes in Patt subterms.
check_cps_subterms_eq pos sr1
checks the critical pairs between all the subterms of the sr1
LHS and all the possible rule LHS's.
val check_cps_sign_with :
Common.Pos.popt ->
Core.Sign.t ->
Core.Term.rule list Core.Term.SymMap.t ->
unit
check_cps_sign_with pos sign sym_map
checks all the critical pairs between all the rules of the signature and sym_map
.
val check_cps :
Common.Pos.popt ->
Core.Sign.t ->
Core.Term.sym_rule list ->
Core.Term.rule list Core.Term.SymMap.t ->
unit
check_cps pos sign srs sym_map
checks all the critical pairs generated by adding srs
.
val update_cp_pos :
Common.Pos.popt ->
Core.Term.cp_pos list Core.Term.SymMap.t ->
Core.Term.rule list Core.Term.SymMap.t ->
Core.Term.cp_pos list Core.Term.SymMap.t
update_cp_pos pos map rs
extends map
by mapping every definable symbol s' such that there is a rule l-->r of rs
and a position p of l such that l_p is headed by s' to (l,r,p,l_p).