package lambdapi
Install
dune-project
Dependency
Authors
Maintainers
Sources
sha256=1066aed2618fd8e6a400c5147dbf55ea977ce8d3fe2e518ac6785c6775a1b8be
sha512=f7f499626aba92e070ae69581299a58525973fdbfd04a160ed3ac89209fb6cbe307b816d0b23e1b75bc83467ce8b4b0530c6f9816eaf58f7a07fde65a450106c
doc/lambdapi.handle/Handle/Rewrite/index.html
Module Handle.RewriteSource
Implementation of the rewrite tactic.
type eq_config = {symb_P : Core.Term.sym;(*Encoding of propositions.
*)symb_T : Core.Term.sym;(*Encoding of types.
*)symb_eq : Core.Term.sym;(*Equality proposition.
*)symb_eqind : Core.Term.sym;(*Induction principle on equality.
*)symb_refl : Core.Term.sym;(*Reflexivity of equality.
*)
}Equality configuration.
get_eq_config ss pos returns the current configuration for equality, used by tactics such as “rewrite” or “reflexivity”.
val get_eq_data :
eq_config ->
Common.Pos.popt ->
Core.Term.term ->
(Core.Term.term * Core.Term.term * Core.Term.term) * Core.Term.var listget_eq_data pos cfg a returns ((a,l,r),[v1;..;vn]) if a ≡ Π v1:A1, .., Π vn:An, P (eq a l r) and fails otherwise.
Type of a term with the free variables that need to be substituted. It is usually used to store the LHS of a proof of equality, together with the variables that were quantified over.
matches p t instantiates the TRef's of p so that p gets equal to t and returns true if all TRef's of p could be instantiated, and false otherwise.
val no_match :
?subterm:bool ->
Common.Pos.popt ->
(Core.Term.var array * Core.Term.term) ->
Core.Term.term ->
'amatching_subs (xs,p) t attempts to match the pattern p containing the variables xs) with the term t. If successful, it returns Some ts where ts is an array of terms such that substituting xs by the corresponding elements of ts in p yields t.
WARNING: Some elements of ts may be uninstantiated TRef's. It will happen if not all vars are in LibTerm.free_vars p, for instance when some vars are type variables not occurring in p, for instance when trying to apply an equation of the form x = ... with x of polymorphic type. This could be improved by generating p_terms instead of terms. Indeed, in this case, we could replace uninstantiated TRef's by underscores.
check_subs vars ts check that no element of ts is an uninstantiated TRef.
val matching_subs_check_TRef :
Common.Pos.popt ->
(Core.Term.var array * Core.Term.term) ->
Core.Term.term ->
Core.Term.term arrayval find_subst :
Common.Pos.popt ->
(Core.Term.var array * Core.Term.term) ->
Core.Term.term ->
Core.Term.term arrayreplace_wild_by_tref t substitutes every wildcard of t by a fresh TRef.
val find_subterm_matching :
Common.Pos.popt ->
Core.Term.term ->
Core.Term.term ->
Core.Term.termbind_pattern p t replaces in the term t every occurence of the pattern p by a fresh variable, and returns the binder on this variable.
val swap :
eq_config ->
Core.Term.term ->
Core.Term.term ->
Core.Term.term ->
Core.Term.term ->
Core.Term.termswap cfg a r l t returns a term of type P (eq a l r) from a term t of type P (eq a r l).
val rewrite :
Core.Sig_state.t ->
Core.Term.problem ->
Common.Pos.popt ->
Proof.goal_typ ->
bool ->
(Core.Term.term, Core.Term.binder) Parsing.Syntax.rw_patt option ->
Core.Term.term ->
Core.Term.termrewrite ss p pos gt l2r pat t generates a term for the refine tactic representing the application of the rewrite tactic to the goal type gt. Every occurrence of the first instance of the left-hand side is replaced by the right-hand side of the obtained proof (or the reverse if l2r is false). pat is an optional SSReflect pattern. t is the equational lemma that is appied. It handles the full set of SSReflect patterns.