Source file normalize.ml

(* This file is free software, part of dolmen. See file "LICENSE" for more information. *)

module Tptp = struct

  let symbol m ~attr ~loc id =
    let t = match id with
      (* Base builtins *)
      | { Id.name =  "$_"; ns = Id.Term }     -> Term.(builtin ~loc Wildcard ())
      | { Id.name = "$tType" ; ns = Id.Term } -> Term.(builtin ~loc Ttype ())
      | { Id.name = "$o"; ns = Id.Term }      -> Term.(builtin ~loc Prop ())
      | { Id.name = "$true"; ns = Id.Term }   -> Term.(builtin ~loc True ())
      | { Id.name = "$false"; ns = Id.Term }  -> Term.(builtin ~loc False ())
      (* Arithmetic builtins *)
      | { Id.name = "$int"; ns = Id.Term }        -> Term.(builtin ~loc Int ())
      | { Id.name = "$less"; ns = Id.Term }       -> Term.(builtin ~loc Lt ())
      | { Id.name = "$lesseq"; ns = Id.Term }     -> Term.(builtin ~loc Leq ())
      | { Id.name = "$greater"; ns = Id.Term }    -> Term.(builtin ~loc Gt ())
      | { Id.name = "$greatereq"; ns = Id.Term }  -> Term.(builtin ~loc Geq ())
      | { Id.name = "$uminus"; ns = Id.Term }     -> Term.(builtin ~loc Minus ())
      | { Id.name = "$sum"; ns = Id.Term }        -> Term.(builtin ~loc Add ())
      | { Id.name = "$difference"; ns = Id.Term } -> Term.(builtin ~loc Sub ())
      | { Id.name = "$product"; ns = Id.Term }    -> Term.(builtin ~loc Mult ())
      | _ -> Term.(const ~loc id)
    in
    let attrs = List.map (Term.map m) attr in
    Term.add_attrs attrs t

  let mapper =
    { Term.id_mapper with symbol }

end

module Smtlib = struct

  let symbol m ~attr ~loc id =
    let t = match id with
      | { Id.name = "Bool"; ns = Id.Sort }  -> Term.(builtin ~loc Prop ())
      | { Id.name = "true"; ns = Id.Term }  -> Term.(builtin ~loc True ())
      | { Id.name = "false"; ns = Id.Term } -> Term.(builtin ~loc False ())
      | { Id.name = "not"; ns = Id.Term }   -> Term.(builtin ~loc Not ())
      | { Id.name = "and"; ns = Id.Term }   -> Term.(builtin ~loc And ())
      | { Id.name = "or"; ns = Id.Term }    -> Term.(builtin ~loc Or ())
      | { Id.name = "xor"; ns = Id.Term }   -> Term.(builtin ~loc Xor ())
      | { Id.name = "=>"; ns = Id.Term }    -> Term.(builtin ~loc Imply ())
      | { Id.name = "="; ns = Id.Term }     -> Term.(builtin ~loc Eq ())
      | { Id.name = "distinct"; ns = Id.Term } -> Term.(builtin ~loc Distinct ())
      | { Id.name = "ite"; ns = Id.Term }   -> Term.(builtin ~loc Ite ())
      | _ -> Term.(const ~loc id)
    in
    let attrs = List.map (Term.map m) attr in
    Term.add_attrs attrs t

  let binder_let_eq m t =
    match t with
    | { Term.term = Term.Colon (u, v) ; _ } ->
      Term.eq ~loc:t.Term.loc (Term.map m u) (Term.map m v)
    | _ -> assert false

  let binder m ~attr ~loc b l body =
    match b with
    | Term.Let ->
      let attrs = List.map (Term.map m) attr in
      let l' = List.map (binder_let_eq m) l in
      Term.add_attrs attrs (Term.letin ~loc l' (Term.map m body))
    | _ -> Term.(id_mapper.binder m ~attr ~loc b l body)

  let mapper =
    { Term.id_mapper with symbol; binder }

end