13577
|
1 |
(* Title: Integ/Int.thy
|
|
2 |
ID: $Id$
|
|
3 |
Author: Lawrence C Paulson, Cambridge University Computer Laboratory
|
|
4 |
Copyright 1998 University of Cambridge
|
|
5 |
*)
|
|
6 |
|
14264
|
7 |
header {*Type "int" is a Linear Order and Other Lemmas*}
|
|
8 |
|
|
9 |
theory Int = IntDef:
|
13577
|
10 |
|
|
11 |
instance int :: order
|
|
12 |
proof qed (assumption | rule zle_refl zle_trans zle_anti_sym int_less_le)+
|
|
13 |
|
|
14 |
instance int :: plus_ac0
|
|
15 |
proof qed (rule zadd_commute zadd_assoc zadd_0)+
|
|
16 |
|
|
17 |
instance int :: linorder
|
|
18 |
proof qed (rule zle_linear)
|
|
19 |
|
|
20 |
constdefs
|
14264
|
21 |
nat :: "int => nat"
|
|
22 |
"nat(Z) == if neg Z then 0 else (THE m. Z = int m)"
|
13577
|
23 |
|
|
24 |
defs (overloaded)
|
14264
|
25 |
zabs_def: "abs(i::int) == if i < 0 then -i else i"
|
|
26 |
|
|
27 |
|
|
28 |
lemma int_0 [simp]: "int 0 = (0::int)"
|
|
29 |
by (simp add: Zero_int_def)
|
|
30 |
|
|
31 |
lemma int_1 [simp]: "int 1 = 1"
|
|
32 |
by (simp add: One_int_def)
|
|
33 |
|
|
34 |
lemma int_Suc0_eq_1: "int (Suc 0) = 1"
|
|
35 |
by (simp add: One_int_def One_nat_def)
|
|
36 |
|
|
37 |
lemma neg_eq_less_0: "neg x = (x < 0)"
|
|
38 |
by (unfold zdiff_def zless_def, auto)
|
|
39 |
|
14266
|
40 |
lemma not_neg_eq_ge_0: "(~neg x) = (0 \<le> x)"
|
14264
|
41 |
apply (unfold zle_def)
|
|
42 |
apply (simp add: neg_eq_less_0)
|
|
43 |
done
|
|
44 |
|
|
45 |
subsection{*To simplify inequalities when Numeral1 can get simplified to 1*}
|
|
46 |
|
|
47 |
lemma not_neg_0: "~ neg 0"
|
|
48 |
by (simp add: One_int_def neg_eq_less_0)
|
|
49 |
|
|
50 |
lemma not_neg_1: "~ neg 1"
|
|
51 |
by (simp add: One_int_def neg_eq_less_0)
|
|
52 |
|
|
53 |
lemma iszero_0: "iszero 0"
|
|
54 |
by (simp add: iszero_def)
|
|
55 |
|
|
56 |
lemma not_iszero_1: "~ iszero 1"
|
|
57 |
by (simp only: Zero_int_def One_int_def One_nat_def iszero_def int_int_eq)
|
|
58 |
|
|
59 |
lemma int_0_less_1: "0 < (1::int)"
|
|
60 |
by (simp only: Zero_int_def One_int_def One_nat_def zless_int)
|
|
61 |
|
|
62 |
lemma int_0_neq_1 [simp]: "0 \<noteq> (1::int)"
|
|
63 |
by (simp only: Zero_int_def One_int_def One_nat_def int_int_eq)
|
|
64 |
|
|
65 |
|
|
66 |
|
|
67 |
subsection{*@{text Abel_Cancel} simproc on the integers*}
|
|
68 |
|
|
69 |
(* Lemmas needed for the simprocs *)
|
|
70 |
|
|
71 |
(*Deletion of other terms in the formula, seeking the -x at the front of z*)
|
|
72 |
lemma zadd_cancel_21: "((x::int) + (y + z) = y + u) = ((x + z) = u)"
|
|
73 |
apply (subst zadd_left_commute)
|
|
74 |
apply (rule zadd_left_cancel)
|
|
75 |
done
|
|
76 |
|
|
77 |
(*A further rule to deal with the case that
|
|
78 |
everything gets cancelled on the right.*)
|
|
79 |
lemma zadd_cancel_end: "((x::int) + (y + z) = y) = (x = -z)"
|
|
80 |
apply (subst zadd_left_commute)
|
|
81 |
apply (rule_tac t = y in zadd_0_right [THEN subst], subst zadd_left_cancel)
|
|
82 |
apply (simp add: eq_zdiff_eq [symmetric])
|
|
83 |
done
|
|
84 |
|
|
85 |
(*Legacy ML bindings, but no longer the structure Int.*)
|
|
86 |
ML
|
|
87 |
{*
|
|
88 |
val Int_thy = the_context ()
|
|
89 |
val zabs_def = thm "zabs_def"
|
|
90 |
val nat_def = thm "nat_def"
|
|
91 |
|
|
92 |
val int_0 = thm "int_0";
|
|
93 |
val int_1 = thm "int_1";
|
|
94 |
val int_Suc0_eq_1 = thm "int_Suc0_eq_1";
|
|
95 |
val neg_eq_less_0 = thm "neg_eq_less_0";
|
|
96 |
val not_neg_eq_ge_0 = thm "not_neg_eq_ge_0";
|
|
97 |
val not_neg_0 = thm "not_neg_0";
|
|
98 |
val not_neg_1 = thm "not_neg_1";
|
|
99 |
val iszero_0 = thm "iszero_0";
|
|
100 |
val not_iszero_1 = thm "not_iszero_1";
|
|
101 |
val int_0_less_1 = thm "int_0_less_1";
|
|
102 |
val int_0_neq_1 = thm "int_0_neq_1";
|
|
103 |
val zadd_cancel_21 = thm "zadd_cancel_21";
|
|
104 |
val zadd_cancel_end = thm "zadd_cancel_end";
|
|
105 |
|
|
106 |
structure Int_Cancel_Data =
|
|
107 |
struct
|
|
108 |
val ss = HOL_ss
|
|
109 |
val eq_reflection = eq_reflection
|
|
110 |
|
|
111 |
val sg_ref = Sign.self_ref (Theory.sign_of (the_context()))
|
|
112 |
val T = HOLogic.intT
|
|
113 |
val zero = Const ("0", HOLogic.intT)
|
|
114 |
val restrict_to_left = restrict_to_left
|
|
115 |
val add_cancel_21 = zadd_cancel_21
|
|
116 |
val add_cancel_end = zadd_cancel_end
|
|
117 |
val add_left_cancel = zadd_left_cancel
|
|
118 |
val add_assoc = zadd_assoc
|
|
119 |
val add_commute = zadd_commute
|
|
120 |
val add_left_commute = zadd_left_commute
|
|
121 |
val add_0 = zadd_0
|
|
122 |
val add_0_right = zadd_0_right
|
|
123 |
|
|
124 |
val eq_diff_eq = eq_zdiff_eq
|
|
125 |
val eqI_rules = [zless_eqI, zeq_eqI, zle_eqI]
|
|
126 |
fun dest_eqI th =
|
|
127 |
#1 (HOLogic.dest_bin "op =" HOLogic.boolT
|
|
128 |
(HOLogic.dest_Trueprop (concl_of th)))
|
|
129 |
|
|
130 |
val diff_def = zdiff_def
|
|
131 |
val minus_add_distrib = zminus_zadd_distrib
|
|
132 |
val minus_minus = zminus_zminus
|
|
133 |
val minus_0 = zminus_0
|
|
134 |
val add_inverses = [zadd_zminus_inverse, zadd_zminus_inverse2]
|
|
135 |
val cancel_simps = [zadd_zminus_cancel, zminus_zadd_cancel]
|
|
136 |
end;
|
|
137 |
|
|
138 |
structure Int_Cancel = Abel_Cancel (Int_Cancel_Data);
|
|
139 |
|
|
140 |
Addsimprocs [Int_Cancel.sum_conv, Int_Cancel.rel_conv];
|
|
141 |
*}
|
|
142 |
|
|
143 |
|
|
144 |
subsection{*Misc Results*}
|
|
145 |
|
|
146 |
lemma zminus_zdiff_eq [simp]: "- (z - y) = y - (z::int)"
|
|
147 |
by simp
|
|
148 |
|
|
149 |
lemma zless_eq_neg: "(w<z) = neg(w-z)"
|
|
150 |
by (simp add: zless_def)
|
|
151 |
|
|
152 |
lemma eq_eq_iszero: "(w=z) = iszero(w-z)"
|
|
153 |
by (simp add: iszero_def zdiff_eq_eq)
|
|
154 |
|
14266
|
155 |
lemma zle_eq_not_neg: "(w\<le>z) = (~ neg(z-w))"
|
14264
|
156 |
by (simp add: zle_def zless_def)
|
|
157 |
|
|
158 |
subsection{*Inequality reasoning*}
|
|
159 |
|
|
160 |
lemma zless_add1_eq: "(w < z + (1::int)) = (w<z | w=z)"
|
|
161 |
apply (auto simp add: zless_iff_Suc_zadd int_Suc gr0_conv_Suc zero_reorient)
|
|
162 |
apply (rule_tac x = "Suc n" in exI)
|
|
163 |
apply (simp add: int_Suc)
|
|
164 |
done
|
|
165 |
|
14266
|
166 |
lemma add1_zle_eq: "(w + (1::int) \<le> z) = (w<z)"
|
14264
|
167 |
apply (simp add: zle_def zless_add1_eq)
|
|
168 |
apply (auto intro: zless_asym zle_anti_sym
|
|
169 |
simp add: order_less_imp_le symmetric zle_def)
|
|
170 |
done
|
|
171 |
|
14266
|
172 |
lemma add1_left_zle_eq: "((1::int) + w \<le> z) = (w<z)"
|
14264
|
173 |
apply (subst zadd_commute)
|
|
174 |
apply (rule add1_zle_eq)
|
|
175 |
done
|
|
176 |
|
|
177 |
|
|
178 |
subsection{*Monotonicity results*}
|
|
179 |
|
|
180 |
lemma zadd_right_cancel_zless [simp]: "(v+z < w+z) = (v < (w::int))"
|
|
181 |
by simp
|
|
182 |
|
|
183 |
lemma zadd_left_cancel_zless [simp]: "(z+v < z+w) = (v < (w::int))"
|
|
184 |
by simp
|
|
185 |
|
14266
|
186 |
lemma zadd_right_cancel_zle [simp] : "(v+z \<le> w+z) = (v \<le> (w::int))"
|
14264
|
187 |
by simp
|
|
188 |
|
14266
|
189 |
lemma zadd_left_cancel_zle [simp] : "(z+v \<le> z+w) = (v \<le> (w::int))"
|
14264
|
190 |
by simp
|
|
191 |
|
14266
|
192 |
(*"v\<le>w ==> v+z \<le> w+z"*)
|
14264
|
193 |
lemmas zadd_zless_mono1 = zadd_right_cancel_zless [THEN iffD2, standard]
|
|
194 |
|
14266
|
195 |
(*"v\<le>w ==> z+v \<le> z+w"*)
|
14264
|
196 |
lemmas zadd_zless_mono2 = zadd_left_cancel_zless [THEN iffD2, standard]
|
|
197 |
|
14266
|
198 |
(*"v\<le>w ==> v+z \<le> w+z"*)
|
14264
|
199 |
lemmas zadd_zle_mono1 = zadd_right_cancel_zle [THEN iffD2, standard]
|
|
200 |
|
14266
|
201 |
(*"v\<le>w ==> z+v \<le> z+w"*)
|
14264
|
202 |
lemmas zadd_zle_mono2 = zadd_left_cancel_zle [THEN iffD2, standard]
|
|
203 |
|
14266
|
204 |
lemma zadd_zle_mono: "[| w'\<le>w; z'\<le>z |] ==> w' + z' \<le> w + (z::int)"
|
14264
|
205 |
by (erule zadd_zle_mono1 [THEN zle_trans], simp)
|
|
206 |
|
14266
|
207 |
lemma zadd_zless_mono: "[| w'<w; z'\<le>z |] ==> w' + z' < w + (z::int)"
|
14264
|
208 |
by (erule zadd_zless_mono1 [THEN order_less_le_trans], simp)
|
|
209 |
|
|
210 |
|
|
211 |
subsection{*Comparison laws*}
|
|
212 |
|
|
213 |
lemma zminus_zless_zminus [simp]: "(- x < - y) = (y < (x::int))"
|
|
214 |
by (simp add: zless_def zdiff_def zadd_ac)
|
|
215 |
|
14266
|
216 |
lemma zminus_zle_zminus [simp]: "(- x \<le> - y) = (y \<le> (x::int))"
|
14264
|
217 |
by (simp add: zle_def)
|
|
218 |
|
|
219 |
text{*The next several equations can make the simplifier loop!*}
|
|
220 |
|
|
221 |
lemma zless_zminus: "(x < - y) = (y < - (x::int))"
|
|
222 |
by (simp add: zless_def zdiff_def zadd_ac)
|
|
223 |
|
|
224 |
lemma zminus_zless: "(- x < y) = (- y < (x::int))"
|
|
225 |
by (simp add: zless_def zdiff_def zadd_ac)
|
|
226 |
|
14266
|
227 |
lemma zle_zminus: "(x \<le> - y) = (y \<le> - (x::int))"
|
14264
|
228 |
by (simp add: zle_def zminus_zless)
|
|
229 |
|
14266
|
230 |
lemma zminus_zle: "(- x \<le> y) = (- y \<le> (x::int))"
|
14264
|
231 |
by (simp add: zle_def zless_zminus)
|
|
232 |
|
|
233 |
lemma equation_zminus: "(x = - y) = (y = - (x::int))"
|
|
234 |
by auto
|
|
235 |
|
|
236 |
lemma zminus_equation: "(- x = y) = (- (y::int) = x)"
|
|
237 |
by auto
|
|
238 |
|
|
239 |
|
|
240 |
subsection{*Instances of the equations above, for zero*}
|
|
241 |
|
|
242 |
(*instantiate a variable to zero and simplify*)
|
|
243 |
|
|
244 |
declare zless_zminus [of 0, simplified, simp]
|
|
245 |
declare zminus_zless [of _ 0, simplified, simp]
|
|
246 |
declare zle_zminus [of 0, simplified, simp]
|
|
247 |
declare zminus_zle [of _ 0, simplified, simp]
|
|
248 |
declare equation_zminus [of 0, simplified, simp]
|
|
249 |
declare zminus_equation [of _ 0, simplified, simp]
|
|
250 |
|
|
251 |
lemma negative_zless_0: "- (int (Suc n)) < 0"
|
|
252 |
by (simp add: zless_def)
|
|
253 |
|
|
254 |
lemma negative_zless [iff]: "- (int (Suc n)) < int m"
|
|
255 |
by (rule negative_zless_0 [THEN order_less_le_trans], simp)
|
|
256 |
|
14266
|
257 |
lemma negative_zle_0: "- int n \<le> 0"
|
14264
|
258 |
by (simp add: zminus_zle)
|
|
259 |
|
14266
|
260 |
lemma negative_zle [iff]: "- int n \<le> int m"
|
14264
|
261 |
by (simp add: zless_def zle_def zdiff_def zadd_int)
|
|
262 |
|
14266
|
263 |
lemma not_zle_0_negative [simp]: "~(0 \<le> - (int (Suc n)))"
|
14264
|
264 |
by (subst zle_zminus, simp)
|
|
265 |
|
14266
|
266 |
lemma int_zle_neg: "(int n \<le> - int m) = (n = 0 & m = 0)"
|
14264
|
267 |
apply safe
|
|
268 |
apply (drule_tac [2] zle_zminus [THEN iffD1])
|
|
269 |
apply (auto dest: zle_trans [OF _ negative_zle_0])
|
|
270 |
done
|
|
271 |
|
|
272 |
lemma not_int_zless_negative [simp]: "~(int n < - int m)"
|
|
273 |
by (simp add: zle_def [symmetric])
|
|
274 |
|
|
275 |
lemma negative_eq_positive [simp]: "(- int n = int m) = (n = 0 & m = 0)"
|
|
276 |
apply (rule iffI)
|
|
277 |
apply (rule int_zle_neg [THEN iffD1])
|
|
278 |
apply (drule sym)
|
|
279 |
apply (simp_all (no_asm_simp))
|
|
280 |
done
|
13577
|
281 |
|
14266
|
282 |
lemma zle_iff_zadd: "(w \<le> z) = (EX n. z = w + int n)"
|
14264
|
283 |
by (force intro: exI [of _ "0::nat"]
|
|
284 |
intro!: not_sym [THEN not0_implies_Suc]
|
|
285 |
simp add: zless_iff_Suc_zadd int_le_less)
|
|
286 |
|
|
287 |
lemma abs_int_eq [simp]: "abs (int m) = int m"
|
|
288 |
by (simp add: zabs_def)
|
|
289 |
|
|
290 |
|
|
291 |
subsection{*nat: magnitide of an integer, as a natural number*}
|
|
292 |
|
|
293 |
lemma nat_int [simp]: "nat(int n) = n"
|
|
294 |
by (unfold nat_def, auto)
|
|
295 |
|
|
296 |
lemma nat_zminus_int [simp]: "nat(- (int n)) = 0"
|
|
297 |
apply (unfold nat_def)
|
|
298 |
apply (auto simp add: neg_eq_less_0 zero_reorient zminus_zless)
|
|
299 |
done
|
|
300 |
|
|
301 |
lemma nat_zero [simp]: "nat 0 = 0"
|
|
302 |
apply (unfold Zero_int_def)
|
|
303 |
apply (rule nat_int)
|
|
304 |
done
|
|
305 |
|
|
306 |
lemma not_neg_nat: "~ neg z ==> int (nat z) = z"
|
|
307 |
apply (drule not_neg_eq_ge_0 [THEN iffD1])
|
|
308 |
apply (drule zle_imp_zless_or_eq)
|
|
309 |
apply (auto simp add: zless_iff_Suc_zadd)
|
|
310 |
done
|
|
311 |
|
|
312 |
lemma negD: "neg x ==> EX n. x = - (int (Suc n))"
|
|
313 |
by (auto simp add: neg_eq_less_0 zless_iff_Suc_zadd zdiff_eq_eq [symmetric] zdiff_def)
|
|
314 |
|
|
315 |
lemma neg_nat: "neg z ==> nat z = 0"
|
|
316 |
by (unfold nat_def, auto)
|
|
317 |
|
|
318 |
lemma zless_nat_eq_int_zless: "(m < nat z) = (int m < z)"
|
|
319 |
apply (case_tac "neg z")
|
|
320 |
apply (erule_tac [2] not_neg_nat [THEN subst])
|
|
321 |
apply (auto simp add: neg_nat)
|
|
322 |
apply (auto dest: order_less_trans simp add: neg_eq_less_0)
|
|
323 |
done
|
|
324 |
|
14266
|
325 |
lemma nat_0_le [simp]: "0 \<le> z ==> int (nat z) = z"
|
14264
|
326 |
by (simp add: neg_eq_less_0 zle_def not_neg_nat)
|
|
327 |
|
14266
|
328 |
lemma nat_le_0 [simp]: "z \<le> 0 ==> nat z = 0"
|
14264
|
329 |
by (auto simp add: order_le_less neg_eq_less_0 zle_def neg_nat)
|
|
330 |
|
14266
|
331 |
(*An alternative condition is 0 \<le> w *)
|
14264
|
332 |
lemma nat_mono_iff: "0 < z ==> (nat w < nat z) = (w < z)"
|
|
333 |
apply (subst zless_int [symmetric])
|
|
334 |
apply (simp (no_asm_simp) add: not_neg_nat not_neg_eq_ge_0 order_le_less)
|
|
335 |
apply (case_tac "neg w")
|
|
336 |
apply (simp add: neg_eq_less_0 neg_nat)
|
|
337 |
apply (blast intro: order_less_trans)
|
|
338 |
apply (simp add: not_neg_nat)
|
|
339 |
done
|
|
340 |
|
|
341 |
lemma zless_nat_conj: "(nat w < nat z) = (0 < z & w < z)"
|
|
342 |
apply (case_tac "0 < z")
|
|
343 |
apply (auto simp add: nat_mono_iff linorder_not_less)
|
|
344 |
done
|
|
345 |
|
|
346 |
(* a case theorem distinguishing non-negative and negative int *)
|
|
347 |
|
|
348 |
lemma int_cases:
|
|
349 |
"[|!! n. z = int n ==> P; !! n. z = - (int (Suc n)) ==> P |] ==> P"
|
|
350 |
apply (case_tac "neg z")
|
|
351 |
apply (fast dest!: negD)
|
|
352 |
apply (drule not_neg_nat [symmetric], auto)
|
|
353 |
done
|
|
354 |
|
|
355 |
|
|
356 |
subsection{*Monotonicity of Multiplication*}
|
|
357 |
|
14266
|
358 |
lemma zmult_zle_mono1_lemma: "i \<le> (j::int) ==> i * int k \<le> j * int k"
|
14264
|
359 |
apply (induct_tac "k")
|
|
360 |
apply (simp_all (no_asm_simp) add: int_Suc zadd_zmult_distrib2 zadd_zle_mono int_Suc0_eq_1)
|
|
361 |
done
|
|
362 |
|
14266
|
363 |
lemma zmult_zle_mono1: "[| i \<le> j; (0::int) \<le> k |] ==> i*k \<le> j*k"
|
14264
|
364 |
apply (rule_tac t = k in not_neg_nat [THEN subst])
|
|
365 |
apply (erule_tac [2] zmult_zle_mono1_lemma)
|
|
366 |
apply (simp (no_asm_use) add: not_neg_eq_ge_0)
|
|
367 |
done
|
|
368 |
|
14266
|
369 |
lemma zmult_zle_mono1_neg: "[| i \<le> j; k \<le> (0::int) |] ==> j*k \<le> i*k"
|
14264
|
370 |
apply (rule zminus_zle_zminus [THEN iffD1])
|
|
371 |
apply (simp add: zmult_zminus_right [symmetric] zmult_zle_mono1 zle_zminus)
|
|
372 |
done
|
|
373 |
|
14266
|
374 |
lemma zmult_zle_mono2: "[| i \<le> j; (0::int) \<le> k |] ==> k*i \<le> k*j"
|
14264
|
375 |
apply (drule zmult_zle_mono1)
|
|
376 |
apply (simp_all add: zmult_commute)
|
|
377 |
done
|
|
378 |
|
14266
|
379 |
lemma zmult_zle_mono2_neg: "[| i \<le> j; k \<le> (0::int) |] ==> k*j \<le> k*i"
|
14264
|
380 |
apply (drule zmult_zle_mono1_neg)
|
|
381 |
apply (simp_all add: zmult_commute)
|
|
382 |
done
|
|
383 |
|
14266
|
384 |
(* \<le> monotonicity, BOTH arguments*)
|
|
385 |
lemma zmult_zle_mono: "[| i \<le> j; k \<le> l; (0::int) \<le> j; (0::int) \<le> k |] ==> i*k \<le> j*l"
|
14264
|
386 |
apply (erule zmult_zle_mono1 [THEN order_trans], assumption)
|
|
387 |
apply (erule zmult_zle_mono2, assumption)
|
|
388 |
done
|
|
389 |
|
|
390 |
|
|
391 |
subsection{*strict, in 1st argument; proof is by induction on k>0*}
|
|
392 |
|
|
393 |
lemma zmult_zless_mono2_lemma: "i<j ==> 0<k --> int k * i < int k * j"
|
|
394 |
apply (induct_tac "k", simp)
|
|
395 |
apply (simp add: int_Suc)
|
|
396 |
apply (case_tac "n=0")
|
|
397 |
apply (simp_all add: zadd_zmult_distrib zadd_zless_mono int_Suc0_eq_1 order_le_less)
|
|
398 |
done
|
|
399 |
|
|
400 |
lemma zmult_zless_mono2: "[| i<j; (0::int) < k |] ==> k*i < k*j"
|
|
401 |
apply (rule_tac t = k in not_neg_nat [THEN subst])
|
|
402 |
apply (erule_tac [2] zmult_zless_mono2_lemma [THEN mp])
|
|
403 |
apply (simp add: not_neg_eq_ge_0 order_le_less)
|
|
404 |
apply (frule conjI [THEN zless_nat_conj [THEN iffD2]], auto)
|
|
405 |
done
|
|
406 |
|
14266
|
407 |
text{*The Integers Form an Ordered Ring*}
|
|
408 |
instance int :: ordered_ring
|
|
409 |
proof
|
|
410 |
fix i j k :: int
|
|
411 |
show "(i + j) + k = i + (j + k)" by simp
|
|
412 |
show "i + j = j + i" by simp
|
|
413 |
show "0 + i = i" by simp
|
|
414 |
show "- i + i = 0" by simp
|
|
415 |
show "i - j = i + (-j)" by simp
|
|
416 |
show "(i * j) * k = i * (j * k)" by (rule zmult_assoc)
|
|
417 |
show "i * j = j * i" by (rule zmult_commute)
|
|
418 |
show "1 * i = i" by simp
|
|
419 |
show "(i + j) * k = i * k + j * k" by (simp add: int_distrib)
|
|
420 |
show "0 \<noteq> (1::int)" by simp
|
|
421 |
show "i \<le> j ==> k + i \<le> k + j" by simp
|
|
422 |
show "i < j ==> 0 < k ==> k * i < k * j" by (simp add: zmult_zless_mono2)
|
|
423 |
show "\<bar>i\<bar> = (if i < 0 then -i else i)" by (simp only: zabs_def)
|
|
424 |
qed
|
|
425 |
|
14264
|
426 |
lemma zmult_zless_mono1: "[| i<j; (0::int) < k |] ==> i*k < j*k"
|
14266
|
427 |
by (rule Ring_and_Field.mult_strict_right_mono)
|
14264
|
428 |
|
|
429 |
(* < monotonicity, BOTH arguments*)
|
14266
|
430 |
lemma zmult_zless_mono:
|
|
431 |
"[| i < j; k < l; (0::int) < j; (0::int) < k |] ==> i*k < j*l"
|
|
432 |
by (rule Ring_and_Field.mult_strict_mono)
|
14264
|
433 |
|
|
434 |
lemma zmult_zless_mono1_neg: "[| i<j; k < (0::int) |] ==> j*k < i*k"
|
14266
|
435 |
by (rule Ring_and_Field.mult_strict_right_mono_neg)
|
14264
|
436 |
|
|
437 |
lemma zmult_zless_mono2_neg: "[| i<j; k < (0::int) |] ==> k*j < k*i"
|
14266
|
438 |
by (rule Ring_and_Field.mult_strict_left_mono_neg)
|
14264
|
439 |
|
|
440 |
lemma zmult_eq_0_iff [iff]: "(m*n = (0::int)) = (m = 0 | n = 0)"
|
14266
|
441 |
by simp
|
|
442 |
|
|
443 |
lemma zmult_zless_cancel2: "(m*k < n*k) = (((0::int) < k & m<n) | (k<0 & n<m))"
|
|
444 |
by (rule Ring_and_Field.mult_less_cancel_right)
|
|
445 |
|
|
446 |
lemma zmult_zless_cancel1:
|
|
447 |
"(k*m < k*n) = (((0::int) < k & m<n) | (k < 0 & n<m))"
|
|
448 |
by (rule Ring_and_Field.mult_less_cancel_left)
|
|
449 |
|
|
450 |
lemma zmult_zle_cancel2:
|
|
451 |
"(m*k \<le> n*k) = (((0::int) < k --> m\<le>n) & (k < 0 --> n\<le>m))"
|
|
452 |
by (rule Ring_and_Field.mult_le_cancel_right)
|
|
453 |
|
|
454 |
lemma zmult_zle_cancel1:
|
|
455 |
"(k*m \<le> k*n) = (((0::int) < k --> m\<le>n) & (k < 0 --> n\<le>m))"
|
|
456 |
by (rule Ring_and_Field.mult_le_cancel_left)
|
|
457 |
|
|
458 |
lemma zmult_cancel2: "(m*k = n*k) = (k = (0::int) | m=n)"
|
|
459 |
by (rule Ring_and_Field.mult_cancel_right)
|
|
460 |
|
|
461 |
lemma zmult_cancel1 [simp]: "(k*m = k*n) = (k = (0::int) | m=n)"
|
|
462 |
by (rule Ring_and_Field.mult_cancel_left)
|
|
463 |
|
|
464 |
(*Analogous to zadd_int*)
|
|
465 |
lemma zdiff_int [rule_format]: "n\<le>m --> int m - int n = int (m-n)"
|
|
466 |
apply (induct_tac m n rule: diff_induct)
|
|
467 |
apply (auto simp add: int_Suc symmetric zdiff_def)
|
14264
|
468 |
done
|
|
469 |
|
|
470 |
|
|
471 |
|
|
472 |
ML
|
|
473 |
{*
|
|
474 |
val zminus_zdiff_eq = thm "zminus_zdiff_eq";
|
|
475 |
val zless_eq_neg = thm "zless_eq_neg";
|
|
476 |
val eq_eq_iszero = thm "eq_eq_iszero";
|
|
477 |
val zle_eq_not_neg = thm "zle_eq_not_neg";
|
|
478 |
val zless_add1_eq = thm "zless_add1_eq";
|
|
479 |
val add1_zle_eq = thm "add1_zle_eq";
|
|
480 |
val add1_left_zle_eq = thm "add1_left_zle_eq";
|
|
481 |
val zadd_right_cancel_zless = thm "zadd_right_cancel_zless";
|
|
482 |
val zadd_left_cancel_zless = thm "zadd_left_cancel_zless";
|
|
483 |
val zadd_right_cancel_zle = thm "zadd_right_cancel_zle";
|
|
484 |
val zadd_left_cancel_zle = thm "zadd_left_cancel_zle";
|
|
485 |
val zadd_zless_mono1 = thm "zadd_zless_mono1";
|
|
486 |
val zadd_zless_mono2 = thm "zadd_zless_mono2";
|
|
487 |
val zadd_zle_mono1 = thm "zadd_zle_mono1";
|
|
488 |
val zadd_zle_mono2 = thm "zadd_zle_mono2";
|
|
489 |
val zadd_zle_mono = thm "zadd_zle_mono";
|
|
490 |
val zadd_zless_mono = thm "zadd_zless_mono";
|
|
491 |
val zminus_zless_zminus = thm "zminus_zless_zminus";
|
|
492 |
val zminus_zle_zminus = thm "zminus_zle_zminus";
|
|
493 |
val zless_zminus = thm "zless_zminus";
|
|
494 |
val zminus_zless = thm "zminus_zless";
|
|
495 |
val zle_zminus = thm "zle_zminus";
|
|
496 |
val zminus_zle = thm "zminus_zle";
|
|
497 |
val equation_zminus = thm "equation_zminus";
|
|
498 |
val zminus_equation = thm "zminus_equation";
|
|
499 |
val negative_zless_0 = thm "negative_zless_0";
|
|
500 |
val negative_zless = thm "negative_zless";
|
|
501 |
val negative_zle_0 = thm "negative_zle_0";
|
|
502 |
val negative_zle = thm "negative_zle";
|
|
503 |
val not_zle_0_negative = thm "not_zle_0_negative";
|
|
504 |
val int_zle_neg = thm "int_zle_neg";
|
|
505 |
val not_int_zless_negative = thm "not_int_zless_negative";
|
|
506 |
val negative_eq_positive = thm "negative_eq_positive";
|
|
507 |
val zle_iff_zadd = thm "zle_iff_zadd";
|
|
508 |
val abs_int_eq = thm "abs_int_eq";
|
|
509 |
val nat_int = thm "nat_int";
|
|
510 |
val nat_zminus_int = thm "nat_zminus_int";
|
|
511 |
val nat_zero = thm "nat_zero";
|
|
512 |
val not_neg_nat = thm "not_neg_nat";
|
|
513 |
val negD = thm "negD";
|
|
514 |
val neg_nat = thm "neg_nat";
|
|
515 |
val zless_nat_eq_int_zless = thm "zless_nat_eq_int_zless";
|
|
516 |
val nat_0_le = thm "nat_0_le";
|
|
517 |
val nat_le_0 = thm "nat_le_0";
|
|
518 |
val zless_nat_conj = thm "zless_nat_conj";
|
|
519 |
val int_cases = thm "int_cases";
|
|
520 |
val zmult_zle_mono1 = thm "zmult_zle_mono1";
|
|
521 |
val zmult_zle_mono1_neg = thm "zmult_zle_mono1_neg";
|
|
522 |
val zmult_zle_mono2 = thm "zmult_zle_mono2";
|
|
523 |
val zmult_zle_mono2_neg = thm "zmult_zle_mono2_neg";
|
|
524 |
val zmult_zle_mono = thm "zmult_zle_mono";
|
|
525 |
val zmult_zless_mono2 = thm "zmult_zless_mono2";
|
|
526 |
val zmult_zless_mono1 = thm "zmult_zless_mono1";
|
|
527 |
val zmult_zless_mono = thm "zmult_zless_mono";
|
|
528 |
val zmult_zless_mono1_neg = thm "zmult_zless_mono1_neg";
|
|
529 |
val zmult_zless_mono2_neg = thm "zmult_zless_mono2_neg";
|
|
530 |
val zmult_eq_0_iff = thm "zmult_eq_0_iff";
|
|
531 |
val zmult_zless_cancel2 = thm "zmult_zless_cancel2";
|
|
532 |
val zmult_zless_cancel1 = thm "zmult_zless_cancel1";
|
|
533 |
val zmult_zle_cancel2 = thm "zmult_zle_cancel2";
|
|
534 |
val zmult_zle_cancel1 = thm "zmult_zle_cancel1";
|
|
535 |
val zmult_cancel2 = thm "zmult_cancel2";
|
|
536 |
val zmult_cancel1 = thm "zmult_cancel1";
|
|
537 |
val zdiff_int = thm "zdiff_int";
|
|
538 |
*}
|
13577
|
539 |
|
|
540 |
end
|