theory Lambda

imports "../Nominal2" 

begin

atom_decl name

nominal_datatype lam =

  Var "name"

| App "lam" "lam"

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

thm lam.distinct

thm lam.induct

thm lam.exhaust lam.strong_exhaust

thm lam.fv_defs

thm lam.bn_defs

thm lam.perm_simps

thm lam.eq_iff

thm lam.fv_bn_eqvt

thm lam.size_eqvt

section {* Typing *}

nominal_datatype ty =

  TVar string

| TFun ty ty ("_ \<rightarrow> _") 

inductive

  valid :: "(name \<times> ty) list \<Rightarrow> bool"

where

  "valid []"

| "\<lbrakk>atom x \<sharp> Gamma; valid Gamma\<rbrakk> \<Longrightarrow> valid ((x, T)#Gamma)"

inductive

  typing :: "(name\<times>ty) list \<Rightarrow> lam \<Rightarrow> ty \<Rightarrow> bool" ("_ \<turnstile> _ : _" [60,60,60] 60) 

where

    t_Var[intro]: "\<lbrakk>valid \<Gamma>; (x, T) \<in> set \<Gamma>\<rbrakk> \<Longrightarrow> \<Gamma> \<turnstile> Var x : T"

  | t_App[intro]: "\<lbrakk>\<Gamma> \<turnstile> t1 : T1 \<rightarrow> T2; \<Gamma> \<turnstile> t2 : T1\<rbrakk> \<Longrightarrow> \<Gamma> \<turnstile> App t1 t2 : T2"

  | t_Lam[intro]: "\<lbrakk>atom x \<sharp> \<Gamma>; (x, T1) # \<Gamma> \<turnstile> t : T2\<rbrakk> \<Longrightarrow> \<Gamma> \<turnstile> Lam x t : T1 \<rightarrow> T2"

equivariance valid

equivariance typing

thm valid.eqvt

thm typing.eqvt

thm eqvts

thm eqvts_raw

thm typing.induct[of "\<Gamma>" "t" "T", no_vars]

lemma

  fixes c::"'a::fs"

  assumes a: "\<Gamma> \<turnstile> t : T" 

  and a1: "\<And>\<Gamma> x T c. \<lbrakk>valid \<Gamma>; (x, T) \<in> set \<Gamma>\<rbrakk> \<Longrightarrow> P c \<Gamma> (Var x) T"

  and a2: "\<And>\<Gamma> t1 T1 T2 t2 c. \<lbrakk>\<Gamma> \<turnstile> t1 : T1 \<rightarrow> T2; \<And>d. P d \<Gamma> t1 T1 \<rightarrow> T2; \<Gamma> \<turnstile> t2 : T1; \<And>d. P d \<Gamma> t2 T1\<rbrakk> 

           \<Longrightarrow> P c \<Gamma> (App t1 t2) T2"

  and a3: "\<And>x \<Gamma> T1 t T2 c. \<lbrakk>atom x \<sharp> c; atom x \<sharp> \<Gamma>; (x, T1) # \<Gamma> \<turnstile> t : T2; \<And>d. P d ((x, T1) # \<Gamma>) t T2\<rbrakk> 

           \<Longrightarrow> P c \<Gamma> (Lam x t) T1 \<rightarrow> T2"

  shows "P c \<Gamma> t T"

proof -

  from a have "\<And>p c. P c (p \<bullet> \<Gamma>) (p \<bullet> t) (p \<bullet> T)"

  proof (induct)

    case (t_Var \<Gamma> x T p c)

    then show ?case

      apply -

      apply(perm_strict_simp)

      apply(rule a1)

      apply(drule_tac p="p" in permute_boolI)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      apply(rotate_tac 1)

      apply(drule_tac p="p" in permute_boolI)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      done

  next

    case (t_App \<Gamma> t1 T1 T2 t2 p c)

    then show ?case

      apply -

      apply(perm_strict_simp)

      apply(rule a2)

      apply(drule_tac p="p" in permute_boolI)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      apply(assumption)

      apply(rotate_tac 2)

      apply(drule_tac p="p" in permute_boolI)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      apply(assumption)

      done

  next

    case (t_Lam x \<Gamma> T1 t T2 p c)

    then show ?case

      apply -

      apply(subgoal_tac "\<exists>q. (q \<bullet> {p \<bullet> atom x}) \<sharp>* c \<and> 

        supp (p \<bullet> \<Gamma>, p \<bullet> Lam x t, p \<bullet> (T1 \<rightarrow> T2)) \<sharp>* q")

      apply(erule exE)

      apply(rule_tac t="p \<bullet> \<Gamma>" and  s="(q + p) \<bullet> \<Gamma>" in subst)

      apply(simp only: permute_plus)

      apply(rule supp_perm_eq)

      apply(simp add: supp_Pair fresh_star_union)

      apply(rule_tac t="p \<bullet> Lam x t" and  s="(q + p) \<bullet> Lam x t" in subst)

      apply(simp only: permute_plus)

      apply(rule supp_perm_eq)

      apply(simp add: supp_Pair fresh_star_union)

      apply(rule_tac t="p \<bullet> (T1 \<rightarrow> T2)" and  s="(q + p) \<bullet> (T1 \<rightarrow> T2)" in subst)

      apply(simp only: permute_plus)

      apply(rule supp_perm_eq)

      apply(simp add: supp_Pair fresh_star_union)

      apply(simp (no_asm) only: eqvts)

      apply(rule a3)

      apply(simp only: eqvts permute_plus)

      apply(simp add: fresh_star_def)

      apply(drule_tac p="q + p" in permute_boolI)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      apply(rotate_tac 1)

      apply(drule_tac p="q + p" in permute_boolI)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      apply(drule_tac x="d" in meta_spec)

      apply(drule_tac x="q + p" in meta_spec)

      apply(perm_strict_simp add: permute_minus_cancel)

      apply(assumption)

      apply(rule at_set_avoiding2)

      apply(simp add: finite_supp)

      apply(simp add: finite_supp)

      apply(simp add: finite_supp)

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

      apply(perm_strict_simp add: permute_minus_cancel)

	--"supplied by the user"

      apply(simp add: fresh_star_prod)

      apply(simp add: fresh_star_def)

      sorry

  qed

  then have "P c (0 \<bullet> \<Gamma>) (0 \<bullet> t) (0 \<bullet> T)" .

  then show "P c \<Gamma> t T" by simp

qed

*)

section {* Matching *}

definition

  MATCH :: "('c::pt \<Rightarrow> (bool * 'a::pt * 'b::pt)) \<Rightarrow> 'b \<Rightarrow> 'a \<Rightarrow> 'b"

where

  "MATCH M d x \<equiv> if (\<exists>!r. \<exists>q. M q = (True, x, r)) then (THE r. \<exists>q. M q = (True, x, r)) else d"

(*

lemma MATCH_eqvt:

  shows "p \<bullet> (MATCH M d x) = MATCH (p \<bullet> M) (p \<bullet> d) (p \<bullet> x)"

unfolding MATCH_def

apply(perm_simp the_eqvt)

apply (tactic {* Nominal_Permeq.eqvt_tac @{context} 1 *})

apply(simp)

thm eqvts_raw 

apply(subst if_eqvt)

apply(subst ex1_eqvt)

apply(subst permute_fun_def)

apply(subst ex_eqvt)

apply(subst permute_fun_def)

apply(subst eq_eqvt)

apply(subst permute_fun_app_eq[where f="M"])

apply(simp only: permute_minus_cancel)

apply(subst permute_prod.simps)

apply(subst permute_prod.simps)

apply(simp only: permute_minus_cancel)

apply(simp only: permute_bool_def)

apply(simp)

apply(subst ex1_eqvt)

apply(subst permute_fun_def)

apply(subst ex_eqvt)

apply(subst permute_fun_def)

apply(subst eq_eqvt)

apply(simp only: eqvts)

apply(simp)

apply(subgoal_tac "(p \<bullet> (\<exists>!r. \<exists>q. M q = (True, x, r))) = (\<exists>!r. \<exists>q. (p \<bullet> M) q = (True, p \<bullet> x, r))")

apply(drule sym)

apply(simp)

apply(rule impI)

apply(simp add: perm_bool)

apply(rule trans)

apply(rule pt_the_eqvt[OF pta at])

apply(assumption)

apply(simp add: pt_ex_eqvt[OF pt at])

apply(simp add: pt_eq_eqvt[OF ptb at])

apply(rule cheat)

apply(rule trans)

apply(rule pt_ex1_eqvt)

apply(rule pta)

apply(rule at)

apply(simp add: pt_ex_eqvt[OF pt at])

apply(simp add: pt_eq_eqvt[OF ptb at])

apply(subst pt_pi_rev[OF pta at])

apply(subst pt_fun_app_eq[OF pt at])

apply(subst pt_pi_rev[OF pt at])

apply(simp)

done

lemma MATCH_cng:

  assumes a: "M1 = M2" "d1 = d2"

  shows "MATCH M1 d1 x = MATCH M2 d2 x"

using a by simp

lemma MATCH_eq:

  assumes a: "t = l x" "G x" "\<And>x'. t = l x' \<Longrightarrow> G x' \<Longrightarrow> r x' = r x"

  shows "MATCH (\<lambda>x. (G x, l x, r x)) d t = r x"

using a

unfolding MATCH_def

apply(subst if_P)

apply(rule_tac a="r x" in ex1I)

apply(rule_tac x="x" in exI)

apply(blast)

apply(erule exE)

apply(drule_tac x="q" in meta_spec)

apply(auto)[1]

apply(rule the_equality)

apply(blast)

apply(erule exE)

apply(drule_tac x="q" in meta_spec)

apply(auto)[1]

done

lemma MATCH_eq2:

  assumes a: "t = l x1 x2" "G x1 x2" "\<And>x1' x2'. t = l x1' x2' \<Longrightarrow> G x1' x2' \<Longrightarrow> r x1' x2' = r x1 x2"

  shows "MATCH (\<lambda>(x1,x2). (G x1 x2, l x1 x2, r x1 x2)) d t = r x1 x2"

sorry

lemma MATCH_neq:

  assumes a: "\<And>x. t = l x \<Longrightarrow> G x \<Longrightarrow> False"

  shows "MATCH (\<lambda>x. (G x, l x, r x)) d t = d"

using a

unfolding MATCH_def

apply(subst if_not_P)

apply(blast)

apply(rule refl)

done

lemma MATCH_neq2:

  assumes a: "\<And>x1 x2. t = l x1 x2 \<Longrightarrow> G x1 x2 \<Longrightarrow> False"

  shows "MATCH (\<lambda>(x1,x2). (G x1 x2, l x1 x2, r x1 x2)) d t = d"

using a

unfolding MATCH_def

apply(subst if_not_P)

apply(auto)

done

*)

ML {*

fun mk_avoids ctxt params name set =

  let

    val (_, ctxt') = ProofContext.add_fixes

      (map (fn (s, T) => (Binding.name s, SOME T, NoSyn)) params) ctxt;

    fun mk s =

      let

        val t = Syntax.read_term ctxt' s;

        val t' = list_abs_free (params, t) |>

          funpow (length params) (fn Abs (_, _, t) => t)

      in (t', HOLogic.dest_setT (fastype_of t)) end

      handle TERM _ =>

        error ("Expression " ^ quote s ^ " to be avoided in case " ^

          quote name ^ " is not a set type");

    fun add_set p [] = [p]

      | add_set (t, T) ((u, U) :: ps) =

          if T = U then

            let val S = HOLogic.mk_setT T

            in (Const (@{const_name sup}, S --> S --> S) $ u $ t, T) :: ps

            end

          else (u, U) :: add_set (t, T) ps

  in

    (mk #> add_set) set 

  end;

*}

ML {* 

  writeln (commas (map (Syntax.string_of_term @{context} o fst) 

    (mk_avoids @{context} [] "t_Var" "{x}" []))) 

*}

ML {*

fun prove_strong_ind (pred_name, avoids) ctxt = 

  Proof.theorem NONE (K I) [] ctxt

local structure P = Parse and K = Keyword in

val _ =

  Outer_Syntax.local_theory_to_proof "nominal_inductive"

    "proves strong induction theorem for inductive predicate involving nominal datatypes" K.thy_goal

      (P.xname -- (Scan.optional (P.$$$ "avoids" |-- P.enum1 "|" (P.name --

        (P.$$$ ":" |-- P.and_list1 P.term))) []) >>  prove_strong_ind)

end;

*}

(*

nominal_inductive typing

*)

(* Substitution *)

primrec match_Var_raw where

  "match_Var_raw (Var_raw x) = Some x"

| "match_Var_raw (App_raw x y) = None"

| "match_Var_raw (Lam_raw n t) = None"

quotient_definition

  "match_Var :: lam \<Rightarrow> name option"

is match_Var_raw

lemma [quot_respect]: "(alpha_lam_raw ===> op =) match_Var_raw match_Var_raw"

  apply rule

  apply (induct_tac x y rule: alpha_lam_raw.induct)

  apply simp_all

  done

lemmas match_Var_simps = match_Var_raw.simps[quot_lifted]

primrec match_App_raw where

  "match_App_raw (Var_raw x) = None"

| "match_App_raw (App_raw x y) = Some (x, y)"

| "match_App_raw (Lam_raw n t) = None"

(*

quotient_definition

  "match_App :: lam \<Rightarrow> (lam \<times> lam) option"

is match_App_raw

lemma [quot_respect]:

  "(alpha_lam_raw ===> option_rel (prod_rel alpha_lam_raw alpha_lam_raw)) match_App_raw match_App_raw"

  apply (intro fun_relI)

  apply (induct_tac a b rule: alpha_lam_raw.induct)

  apply simp_all

  done

lemmas match_App_simps = match_App_raw.simps[quot_lifted]

definition new where

  "new (s :: 'a :: fs) = (THE x. \<forall>a \<in> supp s. atom x \<noteq> a)"

definition

  "match_Lam (S :: 'a :: fs) t = (if (\<exists>n s. (t = Lam n s)) then

    (let z = new (S, t) in Some (z, THE s. t = Lam z s)) else None)"

lemma lam_half_inj: "(Lam z s = Lam z sa) = (s = sa)"

  apply auto

  apply (simp only: lam.eq_iff alphas)

  apply clarify

  apply (simp add: eqvts)

  sorry

lemma match_Lam_simps:

  "match_Lam S (Var n) = None"

  "match_Lam S (App l r) = None"

  "z = new (S, (Lam z s)) \<Longrightarrow> match_Lam S (Lam z s) = Some (z, s)"

  apply (simp_all add: match_Lam_def)

  apply (simp add: lam_half_inj)

  apply auto

  done

*)

(*

lemma match_Lam_simps2:

  "atom n \<sharp> ((S :: 'a :: fs), Lam n s) \<Longrightarrow> match_Lam S (Lam n s) = Some (n, s)"

  apply (rule_tac t="Lam n s"

              and s="Lam (new (S, (Lam n s))) ((n \<leftrightarrow> (new (S, (Lam n s)))) \<bullet> s)" in subst)

  defer

  apply (subst match_Lam_simps(3))

  defer

  apply simp

*)

(*primrec match_Lam_raw where

  "match_Lam_raw (S :: atom set) (Var_raw x) = None"

| "match_Lam_raw S (App_raw x y) = None"

| "match_Lam_raw S (Lam_raw n t) = (let z = new (S \<union> (fv_lam_raw t - {atom n})) in Some (z, (n \<leftrightarrow> z) \<bullet> t))"

quotient_definition

  "match_Lam :: (atom set) \<Rightarrow> lam \<Rightarrow> (name \<times> lam) option"

is match_Lam_raw

lemma swap_fresh:

  assumes a: "fv_lam_raw t \<sharp>* p"

  shows "alpha_lam_raw (p \<bullet> t) t"

  using a apply (induct t)

  apply (simp add: supp_at_base fresh_star_def)

  apply (rule alpha_lam_raw.intros)

  apply (metis Rep_name_inverse atom_eqvt atom_name_def fresh_perm)

  apply (simp)

  apply (simp only: fresh_star_union)

  apply clarify

  apply (rule alpha_lam_raw.intros)

  apply simp

  apply simp

  apply simp

  apply (rule alpha_lam_raw.intros)

  sorry

lemma [quot_respect]:

  "(op = ===> alpha_lam_raw ===> option_rel (prod_rel op = alpha_lam_raw)) match_Lam_raw match_Lam_raw"

  proof (intro fun_relI, clarify)

    fix S t s

    assume a: "alpha_lam_raw t s"

    show "option_rel (prod_rel op = alpha_lam_raw) (match_Lam_raw S t) (match_Lam_raw S s)"

      using a proof (induct t s rule: alpha_lam_raw.induct)

      case goal1 show ?case by simp

    next

      case goal2 show ?case by simp

    next

      case (goal3 x t y s)

      then obtain p where "({atom x}, t) \<approx>gen (\<lambda>x1 x2. alpha_lam_raw x1 x2 \<and>

                              option_rel (prod_rel op = alpha_lam_raw) (match_Lam_raw S x1)

                               (match_Lam_raw S x2)) fv_lam_raw p ({atom y}, s)" ..

      then have

        c: "fv_lam_raw t - {atom x} = fv_lam_raw s - {atom y}" and

        d: "(fv_lam_raw t - {atom x}) \<sharp>* p" and

        e: "alpha_lam_raw (p \<bullet> t) s" and

        f: "option_rel (prod_rel op = alpha_lam_raw) (match_Lam_raw S (p \<bullet> t)) (match_Lam_raw S s)" and

        g: "p \<bullet> {atom x} = {atom y}" unfolding alphas(1) by - (elim conjE, assumption)+

      let ?z = "new (S \<union> (fv_lam_raw t - {atom x}))"

      have h: "?z = new (S \<union> (fv_lam_raw s - {atom y}))" using c by simp

      show ?case

        unfolding match_Lam_raw.simps Let_def option_rel.simps prod_rel.simps split_conv

      proof

        show "?z = new (S \<union> (fv_lam_raw s - {atom y}))" by (fact h)

      next

        have "atom y \<sharp> p" sorry

        have "fv_lam_raw t \<sharp>* ((x \<leftrightarrow> y) \<bullet> p)" sorry

        then have "alpha_lam_raw (((x \<leftrightarrow> y) \<bullet> p) \<bullet> t) t" using swap_fresh by auto

        then have "alpha_lam_raw (p \<bullet> t) ((x \<leftrightarrow> y) \<bullet> t)" sorry

        have "alpha_lam_raw t ((x \<leftrightarrow> y) \<bullet> s)" sorry

        then have "alpha_lam_raw ((x \<leftrightarrow> ?z) \<bullet> t) ((y \<leftrightarrow> ?z) \<bullet> s)" using eqvts(15) sorry

        then show "alpha_lam_raw ((x \<leftrightarrow> new (S \<union> (fv_lam_raw t - {atom x}))) \<bullet> t)

                  ((y \<leftrightarrow> new (S \<union> (fv_lam_raw s - {atom y}))) \<bullet> s)" unfolding h .

      qed

    qed

  qed

lemmas match_Lam_simps = match_Lam_raw.simps[quot_lifted]

*)

(*

lemma app_some: "match_App x = Some (a, b) \<Longrightarrow> x = App a b"

by (induct x rule: lam.induct) (simp_all add: match_App_simps)

lemma lam_some: "match_Lam S x = Some (z, s) \<Longrightarrow> x = Lam z s \<and> atom z \<sharp> S"

  apply (induct x rule: lam.induct)

  apply (simp_all add: match_Lam_simps)

  apply (thin_tac "match_Lam S lam = Some (z, s) \<Longrightarrow> lam = Lam z s \<and> atom z \<sharp> S")

  apply (simp add: match_Lam_def)

  apply (subgoal_tac "\<exists>n s. Lam name lam = Lam n s")

  prefer 2