(*  Title:      HOL/Lifting.thy

    Author:     Brian Huffman and Ondrej Kuncar

    Author:     Cezary Kaliszyk and Christian Urban

*)

header {* Lifting package *}

theory Lifting

imports Plain Equiv_Relations Transfer

keywords

  "print_quotmaps" "print_quotients" :: diag and

  "lift_definition" :: thy_goal and

  "setup_lifting" :: thy_decl

uses

  ("Tools/Lifting/lifting_info.ML")

  ("Tools/Lifting/lifting_term.ML")

  ("Tools/Lifting/lifting_def.ML")

  ("Tools/Lifting/lifting_setup.ML")

begin

subsection {* Function map *}

notation map_fun (infixr "--->" 55)

lemma map_fun_id:

  "(id ---> id) = id"

  by (simp add: fun_eq_iff)

subsection {* Quotient Predicate *}

definition

  "Quotient R Abs Rep T \<longleftrightarrow>

     (\<forall>a. Abs (Rep a) = a) \<and> 

     (\<forall>a. R (Rep a) (Rep a)) \<and>

     (\<forall>r s. R r s \<longleftrightarrow> R r r \<and> R s s \<and> Abs r = Abs s) \<and>

     T = (\<lambda>x y. R x x \<and> Abs x = y)"

lemma QuotientI:

  assumes "\<And>a. Abs (Rep a) = a"

    and "\<And>a. R (Rep a) (Rep a)"

    and "\<And>r s. R r s \<longleftrightarrow> R r r \<and> R s s \<and> Abs r = Abs s"

    and "T = (\<lambda>x y. R x x \<and> Abs x = y)"

  shows "Quotient R Abs Rep T"

  using assms unfolding Quotient_def by blast

lemma Quotient_abs_rep:

  assumes a: "Quotient R Abs Rep T"

  shows "Abs (Rep a) = a"

  using a

  unfolding Quotient_def

  by simp

lemma Quotient_rep_reflp:

  assumes a: "Quotient R Abs Rep T"

  shows "R (Rep a) (Rep a)"

  using a

  unfolding Quotient_def

  by blast

lemma Quotient_rel:

  assumes a: "Quotient R Abs Rep T"

  shows "R r r \<and> R s s \<and> Abs r = Abs s \<longleftrightarrow> R r s" -- {* orientation does not loop on rewriting *}

  using a

  unfolding Quotient_def

  by blast

lemma Quotient_cr_rel:

  assumes a: "Quotient R Abs Rep T"

  shows "T = (\<lambda>x y. R x x \<and> Abs x = y)"

  using a

  unfolding Quotient_def

  by blast

lemma Quotient_refl1: 

  assumes a: "Quotient R Abs Rep T" 

  shows "R r s \<Longrightarrow> R r r"

  using a unfolding Quotient_def 

  by fast

lemma Quotient_refl2: 

  assumes a: "Quotient R Abs Rep T" 

  shows "R r s \<Longrightarrow> R s s"

  using a unfolding Quotient_def 

  by fast

lemma Quotient_rel_rep:

  assumes a: "Quotient R Abs Rep T"

  shows "R (Rep a) (Rep b) \<longleftrightarrow> a = b"

  using a

  unfolding Quotient_def

  by metis

lemma Quotient_rep_abs:

  assumes a: "Quotient R Abs Rep T"

  shows "R r r \<Longrightarrow> R (Rep (Abs r)) r"

  using a unfolding Quotient_def

  by blast

lemma Quotient_rel_abs:

  assumes a: "Quotient R Abs Rep T"

  shows "R r s \<Longrightarrow> Abs r = Abs s"

  using a unfolding Quotient_def

  by blast

lemma Quotient_symp:

  assumes a: "Quotient R Abs Rep T"

  shows "symp R"

  using a unfolding Quotient_def using sympI by (metis (full_types))

lemma Quotient_transp:

  assumes a: "Quotient R Abs Rep T"

  shows "transp R"

  using a unfolding Quotient_def using transpI by (metis (full_types))

lemma Quotient_part_equivp:

  assumes a: "Quotient R Abs Rep T"

  shows "part_equivp R"

by (metis Quotient_rep_reflp Quotient_symp Quotient_transp a part_equivpI)

lemma identity_quotient: "Quotient (op =) id id (op =)"

unfolding Quotient_def by simp 

lemma Quotient_alt_def:

  "Quotient R Abs Rep T \<longleftrightarrow>

    (\<forall>a b. T a b \<longrightarrow> Abs a = b) \<and>

    (\<forall>b. T (Rep b) b) \<and>

    (\<forall>x y. R x y \<longleftrightarrow> T x (Abs x) \<and> T y (Abs y) \<and> Abs x = Abs y)"

apply safe

apply (simp (no_asm_use) only: Quotient_def, fast)

apply (simp (no_asm_use) only: Quotient_def, fast)

apply (simp (no_asm_use) only: Quotient_def, fast)

apply (simp (no_asm_use) only: Quotient_def, fast)

apply (simp (no_asm_use) only: Quotient_def, fast)

apply (simp (no_asm_use) only: Quotient_def, fast)

apply (rule QuotientI)

apply simp

apply metis

apply simp

apply (rule ext, rule ext, metis)

done

lemma Quotient_alt_def2:

  "Quotient R Abs Rep T \<longleftrightarrow>

    (\<forall>a b. T a b \<longrightarrow> Abs a = b) \<and>

    (\<forall>b. T (Rep b) b) \<and>

    (\<forall>x y. R x y \<longleftrightarrow> T x (Abs y) \<and> T y (Abs x))"

  unfolding Quotient_alt_def by (safe, metis+)

lemma fun_quotient:

  assumes 1: "Quotient R1 abs1 rep1 T1"

  assumes 2: "Quotient R2 abs2 rep2 T2"

  shows "Quotient (R1 ===> R2) (rep1 ---> abs2) (abs1 ---> rep2) (T1 ===> T2)"

  using assms unfolding Quotient_alt_def2

  unfolding fun_rel_def fun_eq_iff map_fun_apply

  by (safe, metis+)

lemma apply_rsp:

  fixes f g::"'a \<Rightarrow> 'c"

  assumes q: "Quotient R1 Abs1 Rep1 T1"

  and     a: "(R1 ===> R2) f g" "R1 x y"

  shows "R2 (f x) (g y)"

  using a by (auto elim: fun_relE)

lemma apply_rsp':

  assumes a: "(R1 ===> R2) f g" "R1 x y"

  shows "R2 (f x) (g y)"

  using a by (auto elim: fun_relE)

lemma apply_rsp'':

  assumes "Quotient R Abs Rep T"

  and "(R ===> S) f f"

  shows "S (f (Rep x)) (f (Rep x))"

proof -

  from assms(1) have "R (Rep x) (Rep x)" by (rule Quotient_rep_reflp)

  then show ?thesis using assms(2) by (auto intro: apply_rsp')

qed

subsection {* Quotient composition *}

lemma Quotient_compose:

  assumes 1: "Quotient R1 Abs1 Rep1 T1"

  assumes 2: "Quotient R2 Abs2 Rep2 T2"

  shows "Quotient (T1 OO R2 OO conversep T1) (Abs2 \<circ> Abs1) (Rep1 \<circ> Rep2) (T1 OO T2)"

proof -

  from 1 have Abs1: "\<And>a b. T1 a b \<Longrightarrow> Abs1 a = b"

    unfolding Quotient_alt_def by simp

  from 1 have Rep1: "\<And>b. T1 (Rep1 b) b"

    unfolding Quotient_alt_def by simp

  from 2 have Abs2: "\<And>a b. T2 a b \<Longrightarrow> Abs2 a = b"

    unfolding Quotient_alt_def by simp

  from 2 have Rep2: "\<And>b. T2 (Rep2 b) b"

    unfolding Quotient_alt_def by simp

  from 2 have R2:

    "\<And>x y. R2 x y \<longleftrightarrow> T2 x (Abs2 x) \<and> T2 y (Abs2 y) \<and> Abs2 x = Abs2 y"

    unfolding Quotient_alt_def by simp

  show ?thesis

    unfolding Quotient_alt_def

    apply simp

    apply safe

    apply (drule Abs1, simp)

    apply (erule Abs2)

    apply (rule relcomppI)

    apply (rule Rep1)

    apply (rule Rep2)

    apply (rule relcomppI, assumption)

    apply (drule Abs1, simp)

    apply (clarsimp simp add: R2)

    apply (rule relcomppI, assumption)

    apply (drule Abs1, simp)+

    apply (clarsimp simp add: R2)

    apply (drule Abs1, simp)+

    apply (clarsimp simp add: R2)

    apply (rule relcomppI, assumption)

    apply (rule relcomppI [rotated])

    apply (erule conversepI)

    apply (drule Abs1, simp)+

    apply (simp add: R2)

    done

qed

subsection {* Invariant *}

definition invariant :: "('a \<Rightarrow> bool) \<Rightarrow> 'a \<Rightarrow> 'a \<Rightarrow> bool" 

  where "invariant R = (\<lambda>x y. R x \<and> x = y)"

lemma invariant_to_eq:

  assumes "invariant P x y"

  shows "x = y"

using assms by (simp add: invariant_def)

lemma fun_rel_eq_invariant:

  shows "((invariant R) ===> S) = (\<lambda>f g. \<forall>x. R x \<longrightarrow> S (f x) (g x))"

by (auto simp add: invariant_def fun_rel_def)

lemma invariant_same_args:

  shows "invariant P x x \<equiv> P x"

using assms by (auto simp add: invariant_def)

lemma UNIV_typedef_to_Quotient:

  assumes "type_definition Rep Abs UNIV"

  and T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "Quotient (op =) Abs Rep T"

proof -

  interpret type_definition Rep Abs UNIV by fact

  from Abs_inject Rep_inverse Abs_inverse T_def show ?thesis 

    by (fastforce intro!: QuotientI fun_eq_iff)

qed

lemma UNIV_typedef_to_equivp:

  fixes Abs :: "'a \<Rightarrow> 'b"

  and Rep :: "'b \<Rightarrow> 'a"

  assumes "type_definition Rep Abs (UNIV::'a set)"

  shows "equivp (op=::'a\<Rightarrow>'a\<Rightarrow>bool)"

by (rule identity_equivp)

lemma typedef_to_Quotient:

  assumes "type_definition Rep Abs S"

  and T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "Quotient (Lifting.invariant (\<lambda>x. x \<in> S)) Abs Rep T"

proof -

  interpret type_definition Rep Abs S by fact

  from Rep Abs_inject Rep_inverse Abs_inverse T_def show ?thesis

    by (auto intro!: QuotientI simp: invariant_def fun_eq_iff)

qed

lemma typedef_to_part_equivp:

  assumes "type_definition Rep Abs S"

  shows "part_equivp (Lifting.invariant (\<lambda>x. x \<in> S))"

proof (intro part_equivpI)

  interpret type_definition Rep Abs S by fact

  show "\<exists>x. Lifting.invariant (\<lambda>x. x \<in> S) x x" using Rep by (auto simp: invariant_def)

next

  show "symp (Lifting.invariant (\<lambda>x. x \<in> S))" by (auto intro: sympI simp: invariant_def)

next

  show "transp (Lifting.invariant (\<lambda>x. x \<in> S))" by (auto intro: transpI simp: invariant_def)

qed

lemma open_typedef_to_Quotient:

  assumes "type_definition Rep Abs {x. P x}"

  and T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "Quotient (invariant P) Abs Rep T"

proof -

  interpret type_definition Rep Abs "{x. P x}" by fact

  from Rep Abs_inject Rep_inverse Abs_inverse T_def show ?thesis

    by (auto intro!: QuotientI simp: invariant_def fun_eq_iff)

qed

lemma open_typedef_to_part_equivp:

  assumes "type_definition Rep Abs {x. P x}"

  shows "part_equivp (invariant P)"

proof (intro part_equivpI)

  interpret type_definition Rep Abs "{x. P x}" by fact

  show "\<exists>x. invariant P x x" using Rep by (auto simp: invariant_def)

next

  show "symp (invariant P)" by (auto intro: sympI simp: invariant_def)

next

  show "transp (invariant P)" by (auto intro: transpI simp: invariant_def)

qed

text {* Generating transfer rules for quotients. *}

lemma Quotient_right_unique:

  assumes "Quotient R Abs Rep T" shows "right_unique T"

  using assms unfolding Quotient_alt_def right_unique_def by metis

lemma Quotient_right_total:

  assumes "Quotient R Abs Rep T" shows "right_total T"

  using assms unfolding Quotient_alt_def right_total_def by metis

lemma Quotient_rel_eq_transfer:

  assumes "Quotient R Abs Rep T"

  shows "(T ===> T ===> op =) R (op =)"

  using assms unfolding Quotient_alt_def fun_rel_def by simp

lemma Quotient_bi_total:

  assumes "Quotient R Abs Rep T" and "reflp R"

  shows "bi_total T"

  using assms unfolding Quotient_alt_def bi_total_def reflp_def by auto

lemma Quotient_id_abs_transfer:

  assumes "Quotient R Abs Rep T" and "reflp R"

  shows "(op = ===> T) (\<lambda>x. x) Abs"

  using assms unfolding Quotient_alt_def reflp_def fun_rel_def by simp

text {* Generating transfer rules for a type defined with @{text "typedef"}. *}

lemma typedef_bi_unique:

  assumes type: "type_definition Rep Abs A"

  assumes T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "bi_unique T"

  unfolding bi_unique_def T_def

  by (simp add: type_definition.Rep_inject [OF type])

lemma typedef_right_total:

  assumes T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "right_total T"

  unfolding right_total_def T_def by simp

lemma copy_type_bi_total:

  assumes type: "type_definition Rep Abs UNIV"

  assumes T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "bi_total T"

  unfolding bi_total_def T_def

  by (metis type_definition.Abs_inverse [OF type] UNIV_I)

lemma typedef_transfer_All:

  assumes type: "type_definition Rep Abs A"

  assumes T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "((T ===> op =) ===> op =) (Ball A) All"

  unfolding T_def fun_rel_def

  by (metis type_definition.Rep [OF type]

    type_definition.Abs_inverse [OF type])

lemma typedef_transfer_Ex:

  assumes type: "type_definition Rep Abs A"

  assumes T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "((T ===> op =) ===> op =) (Bex A) Ex"

  unfolding T_def fun_rel_def

  by (metis type_definition.Rep [OF type]

    type_definition.Abs_inverse [OF type])

lemma typedef_transfer_bforall:

  assumes type: "type_definition Rep Abs A"

  assumes T_def: "T \<equiv> (\<lambda>x y. x = Rep y)"

  shows "((T ===> op =) ===> op =)

    (transfer_bforall (\<lambda>x. x \<in> A)) transfer_forall"

  unfolding transfer_bforall_def transfer_forall_def Ball_def [symmetric]

  by (rule typedef_transfer_All [OF assms])

text {* Generating the correspondence rule for a constant defined with

  @{text "lift_definition"}. *}

lemma Quotient_to_transfer:

  assumes "Quotient R Abs Rep T" and "R c c" and "c' \<equiv> Abs c"

  shows "T c c'"

  using assms by (auto dest: Quotient_cr_rel)

subsection {* ML setup *}

text {* Auxiliary data for the lifting package *}

use "Tools/Lifting/lifting_info.ML"

setup Lifting_Info.setup

declare [[map "fun" = (fun_rel, fun_quotient)]]

use "Tools/Lifting/lifting_term.ML"

use "Tools/Lifting/lifting_def.ML"

use "Tools/Lifting/lifting_setup.ML"

hide_const (open) invariant

end