author | wenzelm |
Sat, 28 Nov 2020 15:15:53 +0100 | |
changeset 72755 | 8dffbe01a3e1 |
parent 72269 | 88880eecd7fe |
permissions | -rw-r--r-- |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
1 |
(* Author: Tobias Nipkow *) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
2 |
|
68261 | 3 |
section "Join-Based Implementation of Sets via RBTs" |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
4 |
|
68261 | 5 |
theory Set2_Join_RBT |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
6 |
imports |
68261 | 7 |
Set2_Join |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
8 |
RBT_Set |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
9 |
begin |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
10 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
11 |
subsection "Code" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
12 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
13 |
text \<open> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
14 |
Function \<open>joinL\<close> joins two trees (and an element). |
69597 | 15 |
Precondition: \<^prop>\<open>bheight l \<le> bheight r\<close>. |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
16 |
Method: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
17 |
Descend along the left spine of \<open>r\<close> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
18 |
until you find a subtree with the same \<open>bheight\<close> as \<open>l\<close>, |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
19 |
then combine them into a new red node. |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
20 |
\<close> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
21 |
fun joinL :: "'a rbt \<Rightarrow> 'a \<Rightarrow> 'a rbt \<Rightarrow> 'a rbt" where |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
22 |
"joinL l x r = |
70504 | 23 |
(if bheight l \<ge> bheight r then R l x r |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
24 |
else case r of |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
25 |
B l' x' r' \<Rightarrow> baliL (joinL l x l') x' r' | |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
26 |
R l' x' r' \<Rightarrow> R (joinL l x l') x' r')" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
27 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
28 |
fun joinR :: "'a rbt \<Rightarrow> 'a \<Rightarrow> 'a rbt \<Rightarrow> 'a rbt" where |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
29 |
"joinR l x r = |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
30 |
(if bheight l \<le> bheight r then R l x r |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
31 |
else case l of |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
32 |
B l' x' r' \<Rightarrow> baliR l' x' (joinR r' x r) | |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
33 |
R l' x' r' \<Rightarrow> R l' x' (joinR r' x r))" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
34 |
|
70584 | 35 |
definition join :: "'a rbt \<Rightarrow> 'a \<Rightarrow> 'a rbt \<Rightarrow> 'a rbt" where |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
36 |
"join l x r = |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
37 |
(if bheight l > bheight r |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
38 |
then paint Black (joinR l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
39 |
else if bheight l < bheight r |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
40 |
then paint Black (joinL l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
41 |
else B l x r)" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
42 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
43 |
declare joinL.simps[simp del] |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
44 |
declare joinR.simps[simp del] |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
45 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
46 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
47 |
subsection "Properties" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
48 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
49 |
subsubsection "Color and height invariants" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
50 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
51 |
lemma invc2_joinL: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
52 |
"\<lbrakk> invc l; invc r; bheight l \<le> bheight r \<rbrakk> \<Longrightarrow> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
53 |
invc2 (joinL l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
54 |
\<and> (bheight l \<noteq> bheight r \<and> color r = Black \<longrightarrow> invc(joinL l x r))" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
55 |
proof (induct l x r rule: joinL.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
56 |
case (1 l x r) thus ?case |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
57 |
by(auto simp: invc_baliL invc2I joinL.simps[of l x r] split!: tree.splits if_splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
58 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
59 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
60 |
lemma invc2_joinR: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
61 |
"\<lbrakk> invc l; invh l; invc r; invh r; bheight l \<ge> bheight r \<rbrakk> \<Longrightarrow> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
62 |
invc2 (joinR l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
63 |
\<and> (bheight l \<noteq> bheight r \<and> color l = Black \<longrightarrow> invc(joinR l x r))" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
64 |
proof (induct l x r rule: joinR.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
65 |
case (1 l x r) thus ?case |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
66 |
by(fastforce simp: invc_baliR invc2I joinR.simps[of l x r] split!: tree.splits if_splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
67 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
68 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
69 |
lemma bheight_joinL: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
70 |
"\<lbrakk> invh l; invh r; bheight l \<le> bheight r \<rbrakk> \<Longrightarrow> bheight (joinL l x r) = bheight r" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
71 |
proof (induct l x r rule: joinL.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
72 |
case (1 l x r) thus ?case |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
73 |
by(auto simp: bheight_baliL joinL.simps[of l x r] split!: tree.split) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
74 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
75 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
76 |
lemma invh_joinL: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
77 |
"\<lbrakk> invh l; invh r; bheight l \<le> bheight r \<rbrakk> \<Longrightarrow> invh (joinL l x r)" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
78 |
proof (induct l x r rule: joinL.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
79 |
case (1 l x r) thus ?case |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
80 |
by(auto simp: invh_baliL bheight_joinL joinL.simps[of l x r] split!: tree.split color.split) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
81 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
82 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
83 |
lemma bheight_joinR: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
84 |
"\<lbrakk> invh l; invh r; bheight l \<ge> bheight r \<rbrakk> \<Longrightarrow> bheight (joinR l x r) = bheight l" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
85 |
proof (induct l x r rule: joinR.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
86 |
case (1 l x r) thus ?case |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
87 |
by(fastforce simp: bheight_baliR joinR.simps[of l x r] split!: tree.split) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
88 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
89 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
90 |
lemma invh_joinR: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
91 |
"\<lbrakk> invh l; invh r; bheight l \<ge> bheight r \<rbrakk> \<Longrightarrow> invh (joinR l x r)" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
92 |
proof (induct l x r rule: joinR.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
93 |
case (1 l x r) thus ?case |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
94 |
by(fastforce simp: invh_baliR bheight_joinR joinR.simps[of l x r] |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
95 |
split!: tree.split color.split) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
96 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
97 |
|
72260 | 98 |
text \<open>All invariants in one:\<close> |
99 |
||
100 |
lemma inv_joinL: "\<lbrakk> invc l; invc r; invh l; invh r; bheight l \<le> bheight r \<rbrakk> |
|
101 |
\<Longrightarrow> invc2 (joinL l x r) \<and> (bheight l \<noteq> bheight r \<and> color r = Black \<longrightarrow> invc (joinL l x r)) |
|
102 |
\<and> invh (joinL l x r) \<and> bheight (joinL l x r) = bheight r" |
|
103 |
proof (induct l x r rule: joinL.induct) |
|
104 |
case (1 l x r) thus ?case |
|
105 |
by(auto simp: inv_baliL invc2I joinL.simps[of l x r] split!: tree.splits if_splits) |
|
106 |
qed |
|
107 |
||
108 |
lemma inv_joinR: "\<lbrakk> invc l; invc r; invh l; invh r; bheight l \<ge> bheight r \<rbrakk> |
|
109 |
\<Longrightarrow> invc2 (joinR l x r) \<and> (bheight l \<noteq> bheight r \<and> color l = Black \<longrightarrow> invc (joinR l x r)) |
|
110 |
\<and> invh (joinR l x r) \<and> bheight (joinR l x r) = bheight l" |
|
111 |
proof (induct l x r rule: joinR.induct) |
|
112 |
case (1 l x r) thus ?case |
|
113 |
by(auto simp: inv_baliR invc2I joinR.simps[of l x r] split!: tree.splits if_splits) |
|
114 |
qed |
|
115 |
||
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
116 |
(* unused *) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
117 |
lemma rbt_join: "\<lbrakk> invc l; invh l; invc r; invh r \<rbrakk> \<Longrightarrow> rbt(join l x r)" |
72260 | 118 |
by(simp add: inv_joinL inv_joinR invh_paint rbt_def color_paint_Black join_def) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
119 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
120 |
text \<open>To make sure the the black height is not increased unnecessarily:\<close> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
121 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
122 |
lemma bheight_paint_Black: "bheight(paint Black t) \<le> bheight t + 1" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
123 |
by(cases t) auto |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
124 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
125 |
lemma "\<lbrakk> rbt l; rbt r \<rbrakk> \<Longrightarrow> bheight(join l x r) \<le> max (bheight l) (bheight r) + 1" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
126 |
using bheight_paint_Black[of "joinL l x r"] bheight_paint_Black[of "joinR l x r"] |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
127 |
bheight_joinL[of l r x] bheight_joinR[of l r x] |
70584 | 128 |
by(auto simp: max_def rbt_def join_def) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
129 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
130 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
131 |
subsubsection "Inorder properties" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
132 |
|
69597 | 133 |
text "Currently unused. Instead \<^const>\<open>set_tree\<close> and \<^const>\<open>bst\<close> properties are proved directly." |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
134 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
135 |
lemma inorder_joinL: "bheight l \<le> bheight r \<Longrightarrow> inorder(joinL l x r) = inorder l @ x # inorder r" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
136 |
proof(induction l x r rule: joinL.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
137 |
case (1 l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
138 |
thus ?case by(auto simp: inorder_baliL joinL.simps[of l x r] split!: tree.splits color.splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
139 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
140 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
141 |
lemma inorder_joinR: |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
142 |
"inorder(joinR l x r) = inorder l @ x # inorder r" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
143 |
proof(induction l x r rule: joinR.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
144 |
case (1 l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
145 |
thus ?case by (force simp: inorder_baliR joinR.simps[of l x r] split!: tree.splits color.splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
146 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
147 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
148 |
lemma "inorder(join l x r) = inorder l @ x # inorder r" |
70584 | 149 |
by(auto simp: inorder_joinL inorder_joinR inorder_paint join_def |
150 |
split!: tree.splits color.splits if_splits |
|
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
151 |
dest!: arg_cong[where f = inorder]) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
152 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
153 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
154 |
subsubsection "Set and bst properties" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
155 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
156 |
lemma set_baliL: |
68261 | 157 |
"set_tree(baliL l a r) = set_tree l \<union> {a} \<union> set_tree r" |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
158 |
by(cases "(l,a,r)" rule: baliL.cases) (auto) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
159 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
160 |
lemma set_joinL: |
68261 | 161 |
"bheight l \<le> bheight r \<Longrightarrow> set_tree (joinL l x r) = set_tree l \<union> {x} \<union> set_tree r" |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
162 |
proof(induction l x r rule: joinL.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
163 |
case (1 l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
164 |
thus ?case by(auto simp: set_baliL joinL.simps[of l x r] split!: tree.splits color.splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
165 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
166 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
167 |
lemma set_baliR: |
68261 | 168 |
"set_tree(baliR l a r) = set_tree l \<union> {a} \<union> set_tree r" |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
169 |
by(cases "(l,a,r)" rule: baliR.cases) (auto) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
170 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
171 |
lemma set_joinR: |
68261 | 172 |
"set_tree (joinR l x r) = set_tree l \<union> {x} \<union> set_tree r" |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
173 |
proof(induction l x r rule: joinR.induct) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
174 |
case (1 l x r) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
175 |
thus ?case by(force simp: set_baliR joinR.simps[of l x r] split!: tree.splits color.splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
176 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
177 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
178 |
lemma set_paint: "set_tree (paint c t) = set_tree t" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
179 |
by (cases t) auto |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
180 |
|
68261 | 181 |
lemma set_join: "set_tree (join l x r) = set_tree l \<union> {x} \<union> set_tree r" |
70584 | 182 |
by(simp add: set_joinL set_joinR set_paint join_def) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
183 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
184 |
lemma bst_baliL: |
70582 | 185 |
"\<lbrakk>bst l; bst r; \<forall>x\<in>set_tree l. x < a; \<forall>x\<in>set_tree r. a < x\<rbrakk> |
186 |
\<Longrightarrow> bst (baliL l a r)" |
|
187 |
by(cases "(l,a,r)" rule: baliL.cases) (auto simp: ball_Un) |
|
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
188 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
189 |
lemma bst_baliR: |
70582 | 190 |
"\<lbrakk>bst l; bst r; \<forall>x\<in>set_tree l. x < a; \<forall>x\<in>set_tree r. a < x\<rbrakk> |
191 |
\<Longrightarrow> bst (baliR l a r)" |
|
192 |
by(cases "(l,a,r)" rule: baliR.cases) (auto simp: ball_Un) |
|
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
193 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
194 |
lemma bst_joinL: |
70755
3fb16bed5d6c
replaced new type ('a,'b) tree by old type ('a*'b) tree.
nipkow
parents:
70708
diff
changeset
|
195 |
"\<lbrakk>bst (Node l (a, n) r); bheight l \<le> bheight r\<rbrakk> |
70582 | 196 |
\<Longrightarrow> bst (joinL l a r)" |
197 |
proof(induction l a r rule: joinL.induct) |
|
198 |
case (1 l a r) |
|
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
199 |
thus ?case |
70582 | 200 |
by(auto simp: set_baliL joinL.simps[of l a r] set_joinL ball_Un intro!: bst_baliL |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
201 |
split!: tree.splits color.splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
202 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
203 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
204 |
lemma bst_joinR: |
70582 | 205 |
"\<lbrakk>bst l; bst r; \<forall>x\<in>set_tree l. x < a; \<forall>y\<in>set_tree r. a < y \<rbrakk> |
206 |
\<Longrightarrow> bst (joinR l a r)" |
|
207 |
proof(induction l a r rule: joinR.induct) |
|
208 |
case (1 l a r) |
|
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
209 |
thus ?case |
70582 | 210 |
by(auto simp: set_baliR joinR.simps[of l a r] set_joinR ball_Un intro!: bst_baliR |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
211 |
split!: tree.splits color.splits) |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
212 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
213 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
214 |
lemma bst_paint: "bst (paint c t) = bst t" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
215 |
by(cases t) auto |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
216 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
217 |
lemma bst_join: |
70755
3fb16bed5d6c
replaced new type ('a,'b) tree by old type ('a*'b) tree.
nipkow
parents:
70708
diff
changeset
|
218 |
"bst (Node l (a, n) r) \<Longrightarrow> bst (join l a r)" |
70584 | 219 |
by(auto simp: bst_paint bst_joinL bst_joinR join_def) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
220 |
|
70582 | 221 |
lemma inv_join: "\<lbrakk> invc l; invh l; invc r; invh r \<rbrakk> \<Longrightarrow> invc(join l x r) \<and> invh(join l x r)" |
72269 | 222 |
by (simp add: inv_joinL inv_joinR invh_paint join_def) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
223 |
|
69597 | 224 |
subsubsection "Interpretation of \<^locale>\<open>Set2_Join\<close> with Red-Black Tree" |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
225 |
|
68261 | 226 |
global_interpretation RBT: Set2_Join |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
227 |
where join = join and inv = "\<lambda>t. invc t \<and> invh t" |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
228 |
defines insert_rbt = RBT.insert and delete_rbt = RBT.delete and split_rbt = RBT.split |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
229 |
and join2_rbt = RBT.join2 and split_min_rbt = RBT.split_min |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
230 |
proof (standard, goal_cases) |
68261 | 231 |
case 1 show ?case by (rule set_join) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
232 |
next |
70584 | 233 |
case 2 thus ?case by (simp add: bst_join) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
234 |
next |
68261 | 235 |
case 3 show ?case by simp |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
236 |
next |
70584 | 237 |
case 4 thus ?case by (simp add: inv_join) |
67966
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
238 |
next |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
239 |
case 5 thus ?case by simp |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
240 |
qed |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
241 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
242 |
text \<open>The invariant does not guarantee that the root node is black. This is not required |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
243 |
to guarantee that the height is logarithmic in the size --- Exercise.\<close> |
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
244 |
|
f13796496e82
Added binary set operations with join-based implementation
nipkow
parents:
diff
changeset
|
245 |
end |