src/HOL/Lifting.thy
 author kuncar Mon, 16 Apr 2012 20:50:43 +0200 changeset 47501 0b9294e093db parent 47436 d8fad618a67a child 47521 69f95ac85c3d permissions -rw-r--r--
leave Lifting prefix
```
(*  Title:      HOL/Lifting.thy
Author:     Brian Huffman and Ondrej Kuncar
Author:     Cezary Kaliszyk and Christian Urban
*)

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"

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 (rule relcomppI, assumption)
apply (drule Abs1, simp)+
apply (drule Abs1, simp)+
apply (rule relcomppI, assumption)
apply (rule relcomppI [rotated])
apply (erule conversepI)
apply (drule Abs1, simp)+
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 (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 (invariant (\<lambda>x. x \<in> S))"
proof (intro part_equivpI)
interpret type_definition Rep Abs S by fact
show "\<exists>x. invariant (\<lambda>x. x \<in> S) x x" using Rep by (auto simp: invariant_def)
next
show "symp (invariant (\<lambda>x. x \<in> S))" by (auto intro: sympI simp: invariant_def)
next
show "transp (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
```