Cic.term * (* left side *)
Cic.term * (* right side *)
Utils.comparison) * (* ordering *)
- Cic.metasenv * (* environment for metas *)
- Cic.term list (* arguments *)
+ Cic.metasenv (* environment for metas *)
and proof =
| NoProof (* term is the goal missing a proof *)
match env with
| None -> (
function
- | w, _, (ty, left, right, o), _, _ ->
+ | w, _, (ty, left, right, o), _ ->
Printf.sprintf "Weight: %d, {%s}: %s =(%s) %s" w (CicPp.ppterm ty)
(CicPp.ppterm left) (string_of_comparison o) (CicPp.ppterm right)
)
| Some (_, context, _) -> (
let names = names_of_context context in
function
- | w, _, (ty, left, right, o), _, _ ->
+ | w, _, (ty, left, right, o), _ ->
Printf.sprintf "Weight: %d, {%s}: %s =(%s) %s" w (CicPp.pp ty names)
(CicPp.pp left names) (string_of_comparison o)
(CicPp.pp right names)
| ProofBlock (subst, eq_URI, (name, ty), bo, (pos, eq), eqproof) ->
let t' = Cic.Lambda (name, ty, bo) in
let proof' =
- let _, proof', _, _, _ = eq in
+ let _, proof', _, _ = eq in
do_build_proof proof'
in
let eqproof = do_build_proof eqproof in
- let _, _, (ty, what, other, _), menv', args' = eq in
+ let _, _, (ty, what, other, _), menv' = eq in
let what, other =
if pos = Utils.Left then what, other else other, what
in
let meta_convertibility_eq eq1 eq2 =
- let _, _, (ty, left, right, _), _, _ = eq1
- and _, _, (ty', left', right', _), _, _ = eq2 in
+ let _, _, (ty, left, right, _), _ = eq1
+ and _, _, (ty', left', right', _), _ = eq2 in
if ty <> ty' then
false
else if (left = left') && (right = right') then
let matching = matching1;;
let check_eq context msg eq =
- let w, proof, (eq_ty, left, right, order), metas, args = eq in
+ let w, proof, (eq_ty, left, right, order), metas = eq in
if not (fst (CicReduction.are_convertible ~metasenv:metas context eq_ty
(fst (CicTypeChecker.type_of_aux' metas context left CicUniv.empty_ugraph))
CicUniv.empty_ugraph))
let stat = (ty,t1,t2,o) in
let w = compute_equality_weight stat in
let proof = BasicProof p in
- let e = (w, proof, stat, newmetas, args) in
+ let e = (w, proof, stat, newmetas) in
Some e, (newmeta+1)
| _ -> None, newmeta
)
let o = !Utils.compare_terms t1 t2 in
let stat = (ty,t1,t2,o) in
let w = compute_equality_weight stat in
- let e = (w, BasicProof (C.Rel index), stat, [], []) in
+ let e = (w, BasicProof (C.Rel index), stat, []) in
Some e, (newmeta+1)
| _ -> None, newmeta
in (
let stat = (ty,t1,t2,o) in
let w = compute_equality_weight stat in
let proof = BasicProof p in
- let e = (w, proof, stat, newmetas, args) in
+ let e = (w, proof, stat, newmetas) in
Some e, (newmeta+1)
| _ -> None, newmeta
)
let o = !Utils.compare_terms t1 t2 in
let stat = (ty,t1,t2,o) in
let w = compute_equality_weight stat in
- let e = (w, BasicProof term, stat, [], []) in
+ let e = (w, BasicProof term, stat, []) in
Some e, (newmeta+1)
| _ -> None, newmeta
in
subst, metasenv, newmeta
-let fix_metas newmeta (w, p, (ty, left, right, o), menv, args) =
+let fix_metas newmeta (w, p, (ty, left, right, o), menv) =
(*
let metas = (metas_of_term left)@(metas_of_term right)
@(metas_of_term ty)@(metas_of_proof p) in
let ty = CicMetaSubst.apply_subst subst ty in
let left = CicMetaSubst.apply_subst subst left in
let right = CicMetaSubst.apply_subst subst right in
- let args = List.map (CicMetaSubst.apply_subst subst) args in
let rec fix_proof = function
| NoProof -> NoProof
| BasicProof term -> BasicProof (CicMetaSubst.apply_subst subst term)
@(metas_of_term ty)@(metas_of_proof p) in
let metasenv = List.filter (fun (i, _, _) -> List.mem i metas) metasenv in
*)
- let eq = (w, p, (ty, left, right, o), metasenv, args) in
+ let eq = (w, p, (ty, left, right, o), metasenv) in
(* debug prerr_endline (string_of_equality eq); *)
newmeta+1, eq
let o = !Utils.compare_terms t1 t2 in
let stat = (ty,t1,t2,o) in
let w = compute_equality_weight stat in
- let e = (w, BasicProof proof, stat, [], []) in
+ let e = (w, BasicProof proof, stat, []) in
e
| _ ->
raise TermIsNotAnEquality
type environment = Cic.metasenv * Cic.context * CicUniv.universe_graph;;
let is_weak_identity (metasenv, context, ugraph) = function
- | (_, _, (ty, left, right, _), menv, _) ->
+ | (_, _, (ty, left, right, _), menv) ->
(left = right ||
(meta_convertibility left right))
(* the test below is not a good idea since it stops
;;
let is_identity (metasenv, context, ugraph) = function
- | (_, _, (ty, left, right, _), menv, _) ->
+ | (_, _, (ty, left, right, _), menv) ->
(left = right ||
(* (meta_convertibility left right)) *)
(fst (CicReduction.are_convertible
let term_of_equality equality =
- let _, _, (ty, left, right, _), menv, _ = equality in
+ let _, _, (ty, left, right, _), menv = equality in
let eq i = function Cic.Meta (j, _) -> i = j | _ -> false in
let argsno = List.length menv in
let t =