theory LamTest

imports "../Nominal2" 

begin

atom_decl name

nominal_datatype lam =

  Var "name"

| App "lam" "lam"

| Lam x::"name" l::"lam"  bind x in l

definition

 "eqvt_at f x \<equiv> \<forall>p. p \<bullet> (f x) = f (p \<bullet> x)"

lemma supp_eqvt_at:

  assumes asm: "eqvt_at f x"

  and     fin: "finite (supp x)"

  shows "supp (f x) \<subseteq> supp x"

apply(rule supp_is_subset)

unfolding supports_def

unfolding fresh_def[symmetric]

using asm

apply(simp add: eqvt_at_def)

apply(simp add: swap_fresh_fresh)

apply(rule fin)

done

lemma finite_supp_eqvt_at:

  assumes asm: "eqvt_at f x"

  and     fin: "finite (supp x)"

  shows "finite (supp (f x))"

apply(rule finite_subset)

apply(rule supp_eqvt_at[OF asm fin])

apply(rule fin)

done

definition

 "eqvt f \<equiv> \<forall>p. p \<bullet> f = f"

lemma eqvtI:

  "(\<And>p. p \<bullet> f \<equiv> f) \<Longrightarrow> eqvt f"

apply(auto simp add: eqvt_def)

done

lemma the_default_eqvt:

  assumes unique: "\<exists>!x. P x"

  shows "(p \<bullet> (THE_default d P)) = (THE_default d (p \<bullet> P))"

  apply(rule THE_default1_equality [symmetric])

  apply(rule_tac p="-p" in permute_boolE)

  apply(perm_simp add: permute_minus_cancel)

  apply(rule unique)

  apply(rule_tac p="-p" in permute_boolE)

  apply(perm_simp add: permute_minus_cancel)

  apply(rule THE_defaultI'[OF unique])

  done

lemma fundef_ex1_eqvt:

  fixes x::"'a::pt"

  assumes f_def: "f == (\<lambda>x::'a. THE_default d (G x))"

  assumes eqvt: "eqvt G"

  assumes ex1: "\<exists>!y. G x y"

  shows "(p \<bullet> (f x)) = f (p \<bullet> x)"

  apply (simp only: f_def)

  apply(subst the_default_eqvt)

  apply (rule ex1)

  apply(perm_simp)

  using eqvt

  apply(simp add: eqvt_def)

  done

lemma fundef_ex1_eqvt_at:

  fixes x::"'a::pt"

  assumes f_def: "f == (\<lambda>x::'a. THE_default d (G x))"

  assumes eqvt: "eqvt G"

  assumes ex1: "\<exists>!y. G x y"

  shows "eqvt_at f x"

  unfolding eqvt_at_def

  using assms

  apply(auto intro: fundef_ex1_eqvt)

  done

ML {*

val trace = Unsynchronized.ref false

fun trace_msg msg = if ! trace then tracing (msg ()) else ()

val boolT = HOLogic.boolT

val mk_eq = HOLogic.mk_eq

open Function_Lib

open Function_Common

datatype globals = Globals of

 {fvar: term,

  domT: typ,

  ranT: typ,

  h: term,

  y: term,

  x: term,

  z: term,

  a: term,

  P: term,

  D: term,

  Pbool:term}

datatype rec_call_info = RCInfo of

 {RIvs: (string * typ) list,  (* Call context: fixes and assumes *)

  CCas: thm list,

  rcarg: term,                 (* The recursive argument *)

  llRI: thm,

  h_assum: term}

datatype clause_context = ClauseContext of

 {ctxt : Proof.context,

  qs : term list,

  gs : term list,

  lhs: term,

  rhs: term,

  cqs: cterm list,

  ags: thm list,

  case_hyp : thm}

fun transfer_clause_ctx thy (ClauseContext { ctxt, qs, gs, lhs, rhs, cqs, ags, case_hyp }) =

  ClauseContext { ctxt = ProofContext.transfer thy ctxt,

    qs = qs, gs = gs, lhs = lhs, rhs = rhs, cqs = cqs, ags = ags, case_hyp = case_hyp }

datatype clause_info = ClauseInfo of

 {no: int,

  qglr : ((string * typ) list * term list * term * term),

  cdata : clause_context,

  tree: Function_Ctx_Tree.ctx_tree,

  lGI: thm,

  RCs: rec_call_info list}

*}

thm accp_induct_rule

ML {*

(* Theory dependencies. *)

val acc_induct_rule = @{thm accp_induct_rule}

val ex1_implies_ex = @{thm FunDef.fundef_ex1_existence}

val ex1_implies_un = @{thm FunDef.fundef_ex1_uniqueness}

val ex1_implies_iff = @{thm FunDef.fundef_ex1_iff}

val acc_downward = @{thm accp_downward}

val accI = @{thm accp.accI}

val case_split = @{thm HOL.case_split}

val fundef_default_value = @{thm FunDef.fundef_default_value}

val not_acc_down = @{thm not_accp_down}

fun find_calls tree =

  let

    fun add_Ri (fixes,assumes) (_ $ arg) _ (_, xs) =

      ([], (fixes, assumes, arg) :: xs)

      | add_Ri _ _ _ _ = raise Match

  in

    rev (Function_Ctx_Tree.traverse_tree add_Ri tree [])

  end

*}

ML {*

fun mk_eqvt_at (f_trm, arg_trm) =

  let

    val f_ty = fastype_of f_trm

    val arg_ty = domain_type f_ty

  in

    Const (@{const_name eqvt_at}, [f_ty, arg_ty] ---> @{typ bool}) $ f_trm $ arg_trm

    |> HOLogic.mk_Trueprop

  end

*}

ML {*

fun find_calls2 f t = 

  let

    fun aux (g $ arg) = aux g #> aux arg #> (if f = g then cons ((g, arg)) else I)

      | aux (Abs (_, _, t)) = aux t 

      | aux _ = I

  in

    aux t []

  end 

*}

ML {*

(** building proof obligations *)

fun mk_compat_proof_obligations domT ranT fvar f glrs =

  let

    fun mk_impl ((qs, gs, lhs, rhs), (qs', gs', lhs', rhs')) =

      let

        val shift = incr_boundvars (length qs')

        val RCs_rhs  = find_calls2 fvar rhs

        val RCs_rhs' = find_calls2 fvar rhs'

      in

        Logic.mk_implies

          (HOLogic.mk_Trueprop (HOLogic.eq_const domT $ shift lhs $ lhs'),

            HOLogic.mk_Trueprop (HOLogic.eq_const ranT $ shift rhs $ rhs'))

        |> fold_rev (curry Logic.mk_implies) (map shift gs @ gs')

        |> fold_rev (fn (n,T) => fn b => Term.all T $ Abs(n,T,b)) (qs @ qs')

        |> curry abstract_over fvar

        |> curry subst_bound f

      end

  in

    map mk_impl (unordered_pairs glrs)

  end

*}

ML {*

fun mk_completeness (Globals {x, Pbool, ...}) clauses qglrs =

  let

    fun mk_case (ClauseContext {qs, gs, lhs, ...}, (oqs, _, _, _)) =

      HOLogic.mk_Trueprop Pbool

      |> curry Logic.mk_implies (HOLogic.mk_Trueprop (mk_eq (x, lhs)))

      |> fold_rev (curry Logic.mk_implies) gs

      |> fold_rev mk_forall_rename (map fst oqs ~~ qs)

  in

    HOLogic.mk_Trueprop Pbool

    |> fold_rev (curry Logic.mk_implies o mk_case) (clauses ~~ qglrs)

    |> mk_forall_rename ("x", x)

    |> mk_forall_rename ("P", Pbool)

  end

(** making a context with it's own local bindings **)

fun mk_clause_context x ctxt (pre_qs,pre_gs,pre_lhs,pre_rhs) =

  let

    val (qs, ctxt') = Variable.variant_fixes (map fst pre_qs) ctxt

      |>> map2 (fn (_, T) => fn n => Free (n, T)) pre_qs

    val thy = ProofContext.theory_of ctxt'

    fun inst t = subst_bounds (rev qs, t)

    val gs = map inst pre_gs

    val lhs = inst pre_lhs

    val rhs = inst pre_rhs

    val cqs = map (cterm_of thy) qs

    val ags = map (Thm.assume o cterm_of thy) gs

    val case_hyp = Thm.assume (cterm_of thy (HOLogic.mk_Trueprop (mk_eq (x, lhs))))

  in

    ClauseContext { ctxt = ctxt', qs = qs, gs = gs, lhs = lhs, rhs = rhs,

      cqs = cqs, ags = ags, case_hyp = case_hyp }

  end

(* lowlevel term function. FIXME: remove *)

fun abstract_over_list vs body =

  let

    fun abs lev v tm =

      if v aconv tm then Bound lev

      else

        (case tm of

          Abs (a, T, t) => Abs (a, T, abs (lev + 1) v t)

        | t $ u => abs lev v t $ abs lev v u

        | t => t)

  in

    fold_index (fn (i, v) => fn t => abs i v t) vs body

  end

fun mk_clause_info globals G f no cdata qglr tree RCs GIntro_thm RIntro_thms =

  let

    val Globals {h, ...} = globals

    val ClauseContext { ctxt, qs, cqs, ags, ... } = cdata

    val cert = Thm.cterm_of (ProofContext.theory_of ctxt)

    (* Instantiate the GIntro thm with "f" and import into the clause context. *)

    val lGI = GIntro_thm

      |> Thm.forall_elim (cert f)

      |> fold Thm.forall_elim cqs

      |> fold Thm.elim_implies ags

    fun mk_call_info (rcfix, rcassm, rcarg) RI =

      let

        val llRI = RI

          |> fold Thm.forall_elim cqs

          |> fold (Thm.forall_elim o cert o Free) rcfix

          |> fold Thm.elim_implies ags

          |> fold Thm.elim_implies rcassm

        val h_assum =

          HOLogic.mk_Trueprop (G $ rcarg $ (h $ rcarg))

          |> fold_rev (curry Logic.mk_implies o prop_of) rcassm

          |> fold_rev (Logic.all o Free) rcfix

          |> Pattern.rewrite_term (ProofContext.theory_of ctxt) [(f, h)] []

          |> abstract_over_list (rev qs)

      in

        RCInfo {RIvs=rcfix, rcarg=rcarg, CCas=rcassm, llRI=llRI, h_assum=h_assum}

      end

    val RC_infos = map2 mk_call_info RCs RIntro_thms

  in

    ClauseInfo {no=no, cdata=cdata, qglr=qglr, lGI=lGI, RCs=RC_infos,

      tree=tree}

  end

*}

ML {*

fun store_compat_thms 0 thms = []

  | store_compat_thms n thms =

  let

    val (thms1, thms2) = chop n thms

  in

    (thms1 :: store_compat_thms (n - 1) thms2)

  end

*}

ML {*

  case (prop_of thm) of

    Const ("==>", _) $ (t as (@{term Trueprop} $ (Const (@{const_name eqvt_at}, _) $ _ $ _))) $ _ => 

      let

      in

        Thm.elim_implies el_thm thm 

      end

  | _ => thm

*}

ML {*

(* expects i <= j *)

fun lookup_compat_thm i j cts =

  nth (nth cts (i - 1)) (j - i)

(* Returns "Gsi, Gsj, lhs_i = lhs_j |-- rhs_j_f = rhs_i_f" *)

(* if j < i, then turn around *)

  let

    val ClauseContext {cqs=cqsi,ags=agsi,lhs=lhsi,...} = ctxi

    val ClauseContext {cqs=cqsj,ags=agsj,lhs=lhsj,...} = ctxj

    val lhsi_eq_lhsj = cterm_of thy (HOLogic.mk_Trueprop (mk_eq (lhsi, lhsj)))

  in if j < i then

    let

      val compat = lookup_compat_thm j i cts

    in

      compat         (* "!!qj qi. Gsj => Gsi => lhsj = lhsi ==> rhsj = rhsi" *)

      |> fold Thm.forall_elim (cqsj @ cqsi) (* "Gsj => Gsi => lhsj = lhsi ==> rhsj = rhsi" *)

      |> fold Thm.elim_implies agsj

      |> fold Thm.elim_implies agsi

      |> Thm.elim_implies ((Thm.assume lhsi_eq_lhsj) RS sym) (* "Gsj, Gsi, lhsi = lhsj |-- rhsj = rhsi" *)

    end

    else

    let

      val compat = lookup_compat_thm i j cts

    in

      compat        (* "!!qi qj. Gsi => Gsj => lhsi = lhsj ==> rhsi = rhsj" *)

      |> fold Thm.forall_elim (cqsi @ cqsj) (* "Gsi => Gsj => lhsi = lhsj ==> rhsi = rhsj" *)

      |> fold Thm.elim_implies agsi

      |> fold Thm.elim_implies agsj

      |> Thm.elim_implies (Thm.assume lhsi_eq_lhsj)

      |> (fn thm => thm RS sym) (* "Gsi, Gsj, lhsi = lhsj |-- rhsj = rhsi" *)

    end

  end

*}

ML {*

(* Generates the replacement lemma in fully quantified form. *)

fun mk_replacement_lemma thy h ih_elim clause =

  let

      RCs, tree, ...} = clause

    local open Conv in

      val ih_conv = arg1_conv o arg_conv o arg_conv

    end

    val ih_elim_case =

      Conv.fconv_rule (ih_conv (K (case_hyp RS eq_reflection))) ih_elim

    val Ris = map (fn RCInfo {llRI, ...} => llRI) RCs

    val h_assums = map (fn RCInfo {h_assum, ...} =>

      Thm.assume (cterm_of thy (subst_bounds (rev qs, h_assum)))) RCs

    val (eql, _) =

      Function_Ctx_Tree.rewrite_by_tree thy h ih_elim_case (Ris ~~ h_assums) tree

    val replace_lemma = (eql RS meta_eq_to_obj_eq)

      |> Thm.implies_intr (cprop_of case_hyp)

      |> fold_rev (Thm.implies_intr o cprop_of) h_assums

      |> fold_rev (Thm.implies_intr o cprop_of) ags

      |> fold_rev Thm.forall_intr cqs

      |> Thm.close_derivation

  in

    replace_lemma

  end

*}

ML {*

  let

    val Globals {h, y, x, fvar, ...} = globals

    val ClauseInfo {no=j, qglr=cdescj, RCs=RCsj, ...} = clausej

    val cctxj as ClauseContext {ags = agsj', lhs = lhsj', rhs = rhsj', qs = qsj', cqs = cqsj', ...} =

    val rhsj'h = Pattern.rewrite_term thy [(fvar,h)] [] rhsj'

    val Ghsj' = map 

      (fn RCInfo {h_assum, ...} => Thm.assume (cterm_of thy (subst_bounds (rev qsj', h_assum)))) RCsj

    val RLj_import = RLj

      |> fold Thm.forall_elim cqsj'

      |> fold Thm.elim_implies agsj'

      |> fold Thm.elim_implies Ghsj'

  in