(*  Title:      HOL/Set_Interval.thy

    Author:     Tobias Nipkow

    Author:     Clemens Ballarin

    Author:     Jeremy Avigad

lessThan, greaterThan, atLeast, atMost and two-sided intervals

Modern convention: Ixy stands for an interval where x and y

describe the lower and upper bound and x,y : {c,o,i}

where c = closed, o = open, i = infinite.

Examples: Ico = {_ ..< _} and Ici = {_ ..}

*)

section \<open>Set intervals\<close>

theory Set_Interval

imports Lattices_Big Nat_Transfer

begin

context ord

begin

definition

  lessThan    :: "'a => 'a set" ("(1{..<_})") where

  "{..<u} == {x. x < u}"

definition

  atMost      :: "'a => 'a set" ("(1{.._})") where

  "{..u} == {x. x \<le> u}"

definition

  greaterThan :: "'a => 'a set" ("(1{_<..})") where

  "{l<..} == {x. l<x}"

definition

  atLeast     :: "'a => 'a set" ("(1{_..})") where

  "{l..} == {x. l\<le>x}"

definition

  greaterThanLessThan :: "'a => 'a => 'a set"  ("(1{_<..<_})") where

  "{l<..<u} == {l<..} Int {..<u}"

definition

  atLeastLessThan :: "'a => 'a => 'a set"      ("(1{_..<_})") where

  "{l..<u} == {l..} Int {..<u}"

definition

  greaterThanAtMost :: "'a => 'a => 'a set"    ("(1{_<.._})") where

  "{l<..u} == {l<..} Int {..u}"

definition

  atLeastAtMost :: "'a => 'a => 'a set"        ("(1{_.._})") where

  "{l..u} == {l..} Int {..u}"

end

text\<open>A note of warning when using @{term"{..<n}"} on type @{typ

nat}: it is equivalent to @{term"{0::nat..<n}"} but some lemmas involving

@{term"{m..<n}"} may not exist in @{term"{..<n}"}-form as well.\<close>

syntax

  "_UNION_le"   :: "'a => 'a => 'b set => 'b set"       ("(3UN _<=_./ _)" [0, 0, 10] 10)

  "_UNION_less" :: "'a => 'a => 'b set => 'b set"       ("(3UN _<_./ _)" [0, 0, 10] 10)

  "_INTER_le"   :: "'a => 'a => 'b set => 'b set"       ("(3INT _<=_./ _)" [0, 0, 10] 10)

  "_INTER_less" :: "'a => 'a => 'b set => 'b set"       ("(3INT _<_./ _)" [0, 0, 10] 10)

syntax (xsymbols)

  "_UNION_le"   :: "'a => 'a => 'b set => 'b set"       ("(3\<Union>_\<le>_./ _)" [0, 0, 10] 10)

  "_UNION_less" :: "'a => 'a => 'b set => 'b set"       ("(3\<Union>_<_./ _)" [0, 0, 10] 10)

  "_INTER_le"   :: "'a => 'a => 'b set => 'b set"       ("(3\<Inter>_\<le>_./ _)" [0, 0, 10] 10)

  "_INTER_less" :: "'a => 'a => 'b set => 'b set"       ("(3\<Inter>_<_./ _)" [0, 0, 10] 10)

syntax (latex output)

  "_UNION_le"   :: "'a \<Rightarrow> 'a => 'b set => 'b set"       ("(3\<Union>(00_ \<le> _)/ _)" [0, 0, 10] 10)

  "_UNION_less" :: "'a \<Rightarrow> 'a => 'b set => 'b set"       ("(3\<Union>(00_ < _)/ _)" [0, 0, 10] 10)

  "_INTER_le"   :: "'a \<Rightarrow> 'a => 'b set => 'b set"       ("(3\<Inter>(00_ \<le> _)/ _)" [0, 0, 10] 10)

  "_INTER_less" :: "'a \<Rightarrow> 'a => 'b set => 'b set"       ("(3\<Inter>(00_ < _)/ _)" [0, 0, 10] 10)

translations

  "UN i<=n. A"  == "UN i:{..n}. A"

  "UN i<n. A"   == "UN i:{..<n}. A"

  "INT i<=n. A" == "INT i:{..n}. A"

  "INT i<n. A"  == "INT i:{..<n}. A"

subsection \<open>Various equivalences\<close>

lemma (in ord) lessThan_iff [iff]: "(i: lessThan k) = (i<k)"

by (simp add: lessThan_def)

lemma Compl_lessThan [simp]:

    "!!k:: 'a::linorder. -lessThan k = atLeast k"

apply (auto simp add: lessThan_def atLeast_def)

done

lemma single_Diff_lessThan [simp]: "!!k:: 'a::order. {k} - lessThan k = {k}"

by auto

lemma (in ord) greaterThan_iff [iff]: "(i: greaterThan k) = (k<i)"

by (simp add: greaterThan_def)

lemma Compl_greaterThan [simp]:

    "!!k:: 'a::linorder. -greaterThan k = atMost k"

  by (auto simp add: greaterThan_def atMost_def)

lemma Compl_atMost [simp]: "!!k:: 'a::linorder. -atMost k = greaterThan k"

apply (subst Compl_greaterThan [symmetric])

apply (rule double_complement)

done

lemma (in ord) atLeast_iff [iff]: "(i: atLeast k) = (k<=i)"

by (simp add: atLeast_def)

lemma Compl_atLeast [simp]:

    "!!k:: 'a::linorder. -atLeast k = lessThan k"

  by (auto simp add: lessThan_def atLeast_def)

lemma (in ord) atMost_iff [iff]: "(i: atMost k) = (i<=k)"

by (simp add: atMost_def)

lemma atMost_Int_atLeast: "!!n:: 'a::order. atMost n Int atLeast n = {n}"

by (blast intro: order_antisym)

lemma (in linorder) lessThan_Int_lessThan: "{ a <..} \<inter> { b <..} = { max a b <..}"

  by auto

lemma (in linorder) greaterThan_Int_greaterThan: "{..< a} \<inter> {..< b} = {..< min a b}"

  by auto

subsection \<open>Logical Equivalences for Set Inclusion and Equality\<close>

lemma atLeast_subset_iff [iff]:

     "(atLeast x \<subseteq> atLeast y) = (y \<le> (x::'a::order))"

by (blast intro: order_trans)

lemma atLeast_eq_iff [iff]:

     "(atLeast x = atLeast y) = (x = (y::'a::linorder))"

by (blast intro: order_antisym order_trans)

lemma greaterThan_subset_iff [iff]:

     "(greaterThan x \<subseteq> greaterThan y) = (y \<le> (x::'a::linorder))"

apply (auto simp add: greaterThan_def)

 apply (subst linorder_not_less [symmetric], blast)

done

lemma greaterThan_eq_iff [iff]:

     "(greaterThan x = greaterThan y) = (x = (y::'a::linorder))"

apply (rule iffI)

 apply (erule equalityE)

 apply simp_all

done

lemma atMost_subset_iff [iff]: "(atMost x \<subseteq> atMost y) = (x \<le> (y::'a::order))"

by (blast intro: order_trans)

lemma atMost_eq_iff [iff]: "(atMost x = atMost y) = (x = (y::'a::linorder))"

by (blast intro: order_antisym order_trans)

lemma lessThan_subset_iff [iff]:

     "(lessThan x \<subseteq> lessThan y) = (x \<le> (y::'a::linorder))"

apply (auto simp add: lessThan_def)

 apply (subst linorder_not_less [symmetric], blast)

done

lemma lessThan_eq_iff [iff]:

     "(lessThan x = lessThan y) = (x = (y::'a::linorder))"

apply (rule iffI)

 apply (erule equalityE)

 apply simp_all

done

lemma lessThan_strict_subset_iff:

  fixes m n :: "'a::linorder"

  shows "{..<m} < {..<n} \<longleftrightarrow> m < n"

  by (metis leD lessThan_subset_iff linorder_linear not_less_iff_gr_or_eq psubset_eq)

lemma (in linorder) Ici_subset_Ioi_iff: "{a ..} \<subseteq> {b <..} \<longleftrightarrow> b < a"

  by auto

lemma (in linorder) Iic_subset_Iio_iff: "{.. a} \<subseteq> {..< b} \<longleftrightarrow> a < b"

  by auto

subsection \<open>Two-sided intervals\<close>

context ord

begin

lemma greaterThanLessThan_iff [simp]:

  "(i : {l<..<u}) = (l < i & i < u)"

by (simp add: greaterThanLessThan_def)

lemma atLeastLessThan_iff [simp]:

  "(i : {l..<u}) = (l <= i & i < u)"

by (simp add: atLeastLessThan_def)

lemma greaterThanAtMost_iff [simp]:

  "(i : {l<..u}) = (l < i & i <= u)"

by (simp add: greaterThanAtMost_def)

lemma atLeastAtMost_iff [simp]:

  "(i : {l..u}) = (l <= i & i <= u)"

by (simp add: atLeastAtMost_def)

text \<open>The above four lemmas could be declared as iffs. Unfortunately this

breaks many proofs. Since it only helps blast, it is better to leave them

alone.\<close>

lemma greaterThanLessThan_eq: "{ a <..< b} = { a <..} \<inter> {..< b }"

  by auto

end

subsubsection\<open>Emptyness, singletons, subset\<close>

context order

begin

lemma atLeastatMost_empty[simp]:

  "b < a \<Longrightarrow> {a..b} = {}"

by(auto simp: atLeastAtMost_def atLeast_def atMost_def)

lemma atLeastatMost_empty_iff[simp]:

  "{a..b} = {} \<longleftrightarrow> (~ a <= b)"

by auto (blast intro: order_trans)

lemma atLeastatMost_empty_iff2[simp]:

  "{} = {a..b} \<longleftrightarrow> (~ a <= b)"

by auto (blast intro: order_trans)

lemma atLeastLessThan_empty[simp]:

  "b <= a \<Longrightarrow> {a..<b} = {}"

by(auto simp: atLeastLessThan_def)

lemma atLeastLessThan_empty_iff[simp]:

  "{a..<b} = {} \<longleftrightarrow> (~ a < b)"

by auto (blast intro: le_less_trans)

lemma atLeastLessThan_empty_iff2[simp]:

  "{} = {a..<b} \<longleftrightarrow> (~ a < b)"

by auto (blast intro: le_less_trans)

lemma greaterThanAtMost_empty[simp]: "l \<le> k ==> {k<..l} = {}"

by(auto simp:greaterThanAtMost_def greaterThan_def atMost_def)

lemma greaterThanAtMost_empty_iff[simp]: "{k<..l} = {} \<longleftrightarrow> ~ k < l"

by auto (blast intro: less_le_trans)

lemma greaterThanAtMost_empty_iff2[simp]: "{} = {k<..l} \<longleftrightarrow> ~ k < l"

by auto (blast intro: less_le_trans)

lemma greaterThanLessThan_empty[simp]:"l \<le> k ==> {k<..<l} = {}"

by(auto simp:greaterThanLessThan_def greaterThan_def lessThan_def)

lemma atLeastAtMost_singleton [simp]: "{a..a} = {a}"

by (auto simp add: atLeastAtMost_def atMost_def atLeast_def)

lemma atLeastAtMost_singleton': "a = b \<Longrightarrow> {a .. b} = {a}" by simp

lemma atLeastatMost_subset_iff[simp]:

  "{a..b} <= {c..d} \<longleftrightarrow> (~ a <= b) | c <= a & b <= d"

unfolding atLeastAtMost_def atLeast_def atMost_def

by (blast intro: order_trans)

lemma atLeastatMost_psubset_iff:

  "{a..b} < {c..d} \<longleftrightarrow>

   ((~ a <= b) | c <= a & b <= d & (c < a | b < d))  &  c <= d"

by(simp add: psubset_eq set_eq_iff less_le_not_le)(blast intro: order_trans)

lemma Icc_eq_Icc[simp]:

  "{l..h} = {l'..h'} = (l=l' \<and> h=h' \<or> \<not> l\<le>h \<and> \<not> l'\<le>h')"

by(simp add: order_class.eq_iff)(auto intro: order_trans)

lemma atLeastAtMost_singleton_iff[simp]:

  "{a .. b} = {c} \<longleftrightarrow> a = b \<and> b = c"

proof

  assume "{a..b} = {c}"

  hence *: "\<not> (\<not> a \<le> b)" unfolding atLeastatMost_empty_iff[symmetric] by simp

  with \<open>{a..b} = {c}\<close> have "c \<le> a \<and> b \<le> c" by auto

  with * show "a = b \<and> b = c" by auto

qed simp

lemma Icc_subset_Ici_iff[simp]:

  "{l..h} \<subseteq> {l'..} = (~ l\<le>h \<or> l\<ge>l')"

by(auto simp: subset_eq intro: order_trans)

lemma Icc_subset_Iic_iff[simp]:

  "{l..h} \<subseteq> {..h'} = (~ l\<le>h \<or> h\<le>h')"

by(auto simp: subset_eq intro: order_trans)

lemma not_Ici_eq_empty[simp]: "{l..} \<noteq> {}"

by(auto simp: set_eq_iff)

lemma not_Iic_eq_empty[simp]: "{..h} \<noteq> {}"

by(auto simp: set_eq_iff)

lemmas not_empty_eq_Ici_eq_empty[simp] = not_Ici_eq_empty[symmetric]

lemmas not_empty_eq_Iic_eq_empty[simp] = not_Iic_eq_empty[symmetric]

end

context no_top

begin

(* also holds for no_bot but no_top should suffice *)

lemma not_UNIV_le_Icc[simp]: "\<not> UNIV \<subseteq> {l..h}"

using gt_ex[of h] by(auto simp: subset_eq less_le_not_le)

lemma not_UNIV_le_Iic[simp]: "\<not> UNIV \<subseteq> {..h}"

using gt_ex[of h] by(auto simp: subset_eq less_le_not_le)

lemma not_Ici_le_Icc[simp]: "\<not> {l..} \<subseteq> {l'..h'}"

using gt_ex[of h']

by(auto simp: subset_eq less_le)(blast dest:antisym_conv intro: order_trans)

lemma not_Ici_le_Iic[simp]: "\<not> {l..} \<subseteq> {..h'}"

using gt_ex[of h']

by(auto simp: subset_eq less_le)(blast dest:antisym_conv intro: order_trans)

end

context no_bot

begin

lemma not_UNIV_le_Ici[simp]: "\<not> UNIV \<subseteq> {l..}"

using lt_ex[of l] by(auto simp: subset_eq less_le_not_le)

lemma not_Iic_le_Icc[simp]: "\<not> {..h} \<subseteq> {l'..h'}"

using lt_ex[of l']

by(auto simp: subset_eq less_le)(blast dest:antisym_conv intro: order_trans)

lemma not_Iic_le_Ici[simp]: "\<not> {..h} \<subseteq> {l'..}"

using lt_ex[of l']

by(auto simp: subset_eq less_le)(blast dest:antisym_conv intro: order_trans)

end

context no_top

begin

(* also holds for no_bot but no_top should suffice *)

lemma not_UNIV_eq_Icc[simp]: "\<not> UNIV = {l'..h'}"

using gt_ex[of h'] by(auto simp: set_eq_iff  less_le_not_le)

lemmas not_Icc_eq_UNIV[simp] = not_UNIV_eq_Icc[symmetric]

lemma not_UNIV_eq_Iic[simp]: "\<not> UNIV = {..h'}"

using gt_ex[of h'] by(auto simp: set_eq_iff  less_le_not_le)

lemmas not_Iic_eq_UNIV[simp] = not_UNIV_eq_Iic[symmetric]

lemma not_Icc_eq_Ici[simp]: "\<not> {l..h} = {l'..}"

unfolding atLeastAtMost_def using not_Ici_le_Iic[of l'] by blast

lemmas not_Ici_eq_Icc[simp] = not_Icc_eq_Ici[symmetric]

(* also holds for no_bot but no_top should suffice *)

lemma not_Iic_eq_Ici[simp]: "\<not> {..h} = {l'..}"

using not_Ici_le_Iic[of l' h] by blast

lemmas not_Ici_eq_Iic[simp] = not_Iic_eq_Ici[symmetric]

end

context no_bot

begin

lemma not_UNIV_eq_Ici[simp]: "\<not> UNIV = {l'..}"

using lt_ex[of l'] by(auto simp: set_eq_iff  less_le_not_le)

lemmas not_Ici_eq_UNIV[simp] = not_UNIV_eq_Ici[symmetric]

lemma not_Icc_eq_Iic[simp]: "\<not> {l..h} = {..h'}"

unfolding atLeastAtMost_def using not_Iic_le_Ici[of h'] by blast

lemmas not_Iic_eq_Icc[simp] = not_Icc_eq_Iic[symmetric]

end

context dense_linorder

begin

lemma greaterThanLessThan_empty_iff[simp]:

  "{ a <..< b } = {} \<longleftrightarrow> b \<le> a"

  using dense[of a b] by (cases "a < b") auto

lemma greaterThanLessThan_empty_iff2[simp]:

  "{} = { a <..< b } \<longleftrightarrow> b \<le> a"

  using dense[of a b] by (cases "a < b") auto

lemma atLeastLessThan_subseteq_atLeastAtMost_iff:

  "{a ..< b} \<subseteq> { c .. d } \<longleftrightarrow> (a < b \<longrightarrow> c \<le> a \<and> b \<le> d)"

  using dense[of "max a d" "b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

lemma greaterThanAtMost_subseteq_atLeastAtMost_iff:

  "{a <.. b} \<subseteq> { c .. d } \<longleftrightarrow> (a < b \<longrightarrow> c \<le> a \<and> b \<le> d)"

  using dense[of "a" "min c b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

lemma greaterThanLessThan_subseteq_atLeastAtMost_iff:

  "{a <..< b} \<subseteq> { c .. d } \<longleftrightarrow> (a < b \<longrightarrow> c \<le> a \<and> b \<le> d)"

  using dense[of "a" "min c b"] dense[of "max a d" "b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

lemma atLeastAtMost_subseteq_atLeastLessThan_iff:

  "{a .. b} \<subseteq> { c ..< d } \<longleftrightarrow> (a \<le> b \<longrightarrow> c \<le> a \<and> b < d)"

  using dense[of "max a d" "b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

lemma greaterThanAtMost_subseteq_atLeastLessThan_iff:

  "{a <.. b} \<subseteq> { c ..< d } \<longleftrightarrow> (a < b \<longrightarrow> c \<le> a \<and> b < d)"

  using dense[of "a" "min c b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

lemma greaterThanLessThan_subseteq_atLeastLessThan_iff:

  "{a <..< b} \<subseteq> { c ..< d } \<longleftrightarrow> (a < b \<longrightarrow> c \<le> a \<and> b \<le> d)"

  using dense[of "a" "min c b"] dense[of "max a d" "b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

lemma greaterThanLessThan_subseteq_greaterThanAtMost_iff:

  "{a <..< b} \<subseteq> { c <.. d } \<longleftrightarrow> (a < b \<longrightarrow> c \<le> a \<and> b \<le> d)"

  using dense[of "a" "min c b"] dense[of "max a d" "b"]

  by (force simp: subset_eq Ball_def not_less[symmetric])

end

context no_top

begin

lemma greaterThan_non_empty[simp]: "{x <..} \<noteq> {}"

  using gt_ex[of x] by auto

end

context no_bot

begin

lemma lessThan_non_empty[simp]: "{..< x} \<noteq> {}"

  using lt_ex[of x] by auto

end

lemma (in linorder) atLeastLessThan_subset_iff:

  "{a..<b} <= {c..<d} \<Longrightarrow> b <= a | c<=a & b<=d"

apply (auto simp:subset_eq Ball_def)

apply(frule_tac x=a in spec)

apply(erule_tac x=d in allE)

apply (simp add: less_imp_le)

done

lemma atLeastLessThan_inj:

  fixes a b c d :: "'a::linorder"

  assumes eq: "{a ..< b} = {c ..< d}" and "a < b" "c < d"

  shows "a = c" "b = d"

using assms by (metis atLeastLessThan_subset_iff eq less_le_not_le linorder_antisym_conv2 subset_refl)+

lemma atLeastLessThan_eq_iff:

  fixes a b c d :: "'a::linorder"

  assumes "a < b" "c < d"

  shows "{a ..< b} = {c ..< d} \<longleftrightarrow> a = c \<and> b = d"

  using atLeastLessThan_inj assms by auto

lemma (in linorder) Ioc_inj: "{a <.. b} = {c <.. d} \<longleftrightarrow> (b \<le> a \<and> d \<le> c) \<or> a = c \<and> b = d"

  by (metis eq_iff greaterThanAtMost_empty_iff2 greaterThanAtMost_iff le_cases not_le)

lemma (in order) Iio_Int_singleton: "{..<k} \<inter> {x} = (if x < k then {x} else {})"

  by auto

lemma (in linorder) Ioc_subset_iff: "{a<..b} \<subseteq> {c<..d} \<longleftrightarrow> (b \<le> a \<or> c \<le> a \<and> b \<le> d)"

  by (auto simp: subset_eq Ball_def) (metis less_le not_less)

lemma (in order_bot) atLeast_eq_UNIV_iff: "{x..} = UNIV \<longleftrightarrow> x = bot"

by (auto simp: set_eq_iff intro: le_bot)

lemma (in order_top) atMost_eq_UNIV_iff: "{..x} = UNIV \<longleftrightarrow> x = top"

by (auto simp: set_eq_iff intro: top_le)

lemma (in bounded_lattice) atLeastAtMost_eq_UNIV_iff:

  "{x..y} = UNIV \<longleftrightarrow> (x = bot \<and> y = top)"

by (auto simp: set_eq_iff intro: top_le le_bot)

lemma Iio_eq_empty_iff: "{..< n::'a::{linorder, order_bot}} = {} \<longleftrightarrow> n = bot"

  by (auto simp: set_eq_iff not_less le_bot)

lemma Iio_eq_empty_iff_nat: "{..< n::nat} = {} \<longleftrightarrow> n = 0"

  by (simp add: Iio_eq_empty_iff bot_nat_def)

lemma mono_image_least:

  assumes f_mono: "mono f" and f_img: "f ` {m ..< n} = {m' ..< n'}" "m < n"

  shows "f m = m'"

proof -

  from f_img have "{m' ..< n'} \<noteq> {}"

    by (metis atLeastLessThan_empty_iff image_is_empty)

  with f_img have "m' \<in> f ` {m ..< n}" by auto

  then obtain k where "f k = m'" "m \<le> k" by auto

  moreover have "m' \<le> f m" using f_img by auto

  ultimately show "f m = m'"

    using f_mono by (auto elim: monoE[where x=m and y=k])

qed

subsection \<open>Infinite intervals\<close>

context dense_linorder

begin

lemma infinite_Ioo:

  assumes "a < b"

  shows "\<not> finite {a<..<b}"

proof

  assume fin: "finite {a<..<b}"

  moreover have ne: "{a<..<b} \<noteq> {}"

    using \<open>a < b\<close> by auto

  ultimately have "a < Max {a <..< b}" "Max {a <..< b} < b"

    using Max_in[of "{a <..< b}"] by auto

  then obtain x where "Max {a <..< b} < x" "x < b"

    using dense[of "Max {a<..<b}" b] by auto

  then have "x \<in> {a <..< b}"

    using \<open>a < Max {a <..< b}\<close> by auto

  then have "x \<le> Max {a <..< b}"

    using fin by auto

  with \<open>Max {a <..< b} < x\<close> show False by auto

qed

lemma infinite_Icc: "a < b \<Longrightarrow> \<not> finite {a .. b}"

  using greaterThanLessThan_subseteq_atLeastAtMost_iff[of a b a b] infinite_Ioo[of a b]

  by (auto dest: finite_subset)

lemma infinite_Ico: "a < b \<Longrightarrow> \<not> finite {a ..< b}"

  using greaterThanLessThan_subseteq_atLeastLessThan_iff[of a b a b] infinite_Ioo[of a b]

  by (auto dest: finite_subset)

lemma infinite_Ioc: "a < b \<Longrightarrow> \<not> finite {a <.. b}"

  using greaterThanLessThan_subseteq_greaterThanAtMost_iff[of a b a b] infinite_Ioo[of a b]

  by (auto dest: finite_subset)

end

lemma infinite_Iio: "\<not> finite {..< a :: 'a :: {no_bot, linorder}}"

proof

  assume "finite {..< a}"

  then have *: "\<And>x. x < a \<Longrightarrow> Min {..< a} \<le> x"

    by auto

  obtain x where "x < a"

    using lt_ex by auto

  obtain y where "y < Min {..< a}"

    using lt_ex by auto

  also have "Min {..< a} \<le> x"

    using \<open>x < a\<close> by fact

  also note \<open>x < a\<close>

  finally have "Min {..< a} \<le> y"

    by fact

  with \<open>y < Min {..< a}\<close> show False by auto

qed

lemma infinite_Iic: "\<not> finite {.. a :: 'a :: {no_bot, linorder}}"

  using infinite_Iio[of a] finite_subset[of "{..< a}" "{.. a}"]

  by (auto simp: subset_eq less_imp_le)

lemma infinite_Ioi: "\<not> finite {a :: 'a :: {no_top, linorder} <..}"

proof

  assume "finite {a <..}"

  then have *: "\<And>x. a < x \<Longrightarrow> x \<le> Max {a <..}"

    by auto

  obtain y where "Max {a <..} < y"

    using gt_ex by auto

  obtain x where "a < x"

    using gt_ex by auto

  also then have "x \<le> Max {a <..}"

    by fact

  also note \<open>Max {a <..} < y\<close>

  finally have "y \<le> Max { a <..}"

    by fact

  with \<open>Max {a <..} < y\<close> show False by auto

qed

lemma infinite_Ici: "\<not> finite {a :: 'a :: {no_top, linorder} ..}"

  using infinite_Ioi[of a] finite_subset[of "{a <..}" "{a ..}"]

  by (auto simp: subset_eq less_imp_le)

subsubsection \<open>Intersection\<close>

context linorder

begin

lemma Int_atLeastAtMost[simp]: "{a..b} Int {c..d} = {max a c .. min b d}"

by auto

lemma Int_atLeastAtMostR1[simp]: "{..b} Int {c..d} = {c .. min b d}"

by auto

lemma Int_atLeastAtMostR2[simp]: "{a..} Int {c..d} = {max a c .. d}"

by auto

lemma Int_atLeastAtMostL1[simp]: "{a..b} Int {..d} = {a .. min b d}"

by auto

lemma Int_atLeastAtMostL2[simp]: "{a..b} Int {c..} = {max a c .. b}"

by auto

lemma Int_atLeastLessThan[simp]: "{a..<b} Int {c..<d} = {max a c ..< min b d}"

by auto

lemma Int_greaterThanAtMost[simp]: "{a<..b} Int {c<..d} = {max a c <.. min b d}"

by auto

lemma Int_greaterThanLessThan[simp]: "{a<..<b} Int {c<..<d} = {max a c <..< min b d}"

by auto

lemma Int_atMost[simp]: "{..a} \<inter> {..b} = {.. min a b}"

  by (auto simp: min_def)

lemma Ioc_disjoint: "{a<..b} \<inter> {c<..d} = {} \<longleftrightarrow> b \<le> a \<or> d \<le> c \<or> b \<le> c \<or> d \<le> a"

  using assms by auto

end

context complete_lattice

begin

lemma

  shows Sup_atLeast[simp]: "Sup {x ..} = top"

    and Sup_greaterThanAtLeast[simp]: "x < top \<Longrightarrow> Sup {x <..} = top"

    and Sup_atMost[simp]: "Sup {.. y} = y"

    and Sup_atLeastAtMost[simp]: "x \<le> y \<Longrightarrow> Sup { x .. y} = y"

    and Sup_greaterThanAtMost[simp]: "x < y \<Longrightarrow> Sup { x <.. y} = y"

  by (auto intro!: Sup_eqI)

lemma

  shows Inf_atMost[simp]: "Inf {.. x} = bot"

    and Inf_atMostLessThan[simp]: "top < x \<Longrightarrow> Inf {..< x} = bot"

    and Inf_atLeast[simp]: "Inf {x ..} = x"

    and Inf_atLeastAtMost[simp]: "x \<le> y \<Longrightarrow> Inf { x .. y} = x"

    and Inf_atLeastLessThan[simp]: "x < y \<Longrightarrow> Inf { x ..< y} = x"

  by (auto intro!: Inf_eqI)

end

lemma

  fixes x y :: "'a :: {complete_lattice, dense_linorder}"

  shows Sup_lessThan[simp]: "Sup {..< y} = y"

    and Sup_atLeastLessThan[simp]: "x < y \<Longrightarrow> Sup { x ..< y} = y"

    and Sup_greaterThanLessThan[simp]: "x < y \<Longrightarrow> Sup { x <..< y} = y"

    and Inf_greaterThan[simp]: "Inf {x <..} = x"

    and Inf_greaterThanAtMost[simp]: "x < y \<Longrightarrow> Inf { x <.. y} = x"

    and Inf_greaterThanLessThan[simp]: "x < y \<Longrightarrow> Inf { x <..< y} = x"

  by (auto intro!: Inf_eqI Sup_eqI intro: dense_le dense_le_bounded dense_ge dense_ge_bounded)

subsection \<open>Intervals of natural numbers\<close>

subsubsection \<open>The Constant @{term lessThan}\<close>

lemma lessThan_0 [simp]: "lessThan (0::nat) = {}"

by (simp add: lessThan_def)

lemma lessThan_Suc: "lessThan (Suc k) = insert k (lessThan k)"

by (simp add: lessThan_def less_Suc_eq, blast)

text \<open>The following proof is convenient in induction proofs where

new elements get indices at the beginning. So it is used to transform

@{term "{..<Suc n}"} to @{term "0::nat"} and @{term "{..< n}"}.\<close>

lemma zero_notin_Suc_image: "0 \<notin> Suc ` A"

  by auto

lemma lessThan_Suc_eq_insert_0: "{..<Suc n} = insert 0 (Suc ` {..<n})"

  by (auto simp: image_iff less_Suc_eq_0_disj)

lemma lessThan_Suc_atMost: "lessThan (Suc k) = atMost k"

by (simp add: lessThan_def atMost_def less_Suc_eq_le)

lemma Iic_Suc_eq_insert_0: "{.. Suc n} = insert 0 (Suc ` {.. n})"

  unfolding lessThan_Suc_atMost[symmetric] lessThan_Suc_eq_insert_0[of "Suc n"] ..

lemma UN_lessThan_UNIV: "(UN m::nat. lessThan m) = UNIV"

by blast

subsubsection \<open>The Constant @{term greaterThan}\<close>

lemma greaterThan_0 [simp]: "greaterThan 0 = range Suc"

apply (simp add: greaterThan_def)

apply (blast dest: gr0_conv_Suc [THEN iffD1])

done

lemma greaterThan_Suc: "greaterThan (Suc k) = greaterThan k - {Suc k}"

apply (simp add: greaterThan_def)

apply (auto elim: linorder_neqE)

done

lemma INT_greaterThan_UNIV: "(INT m::nat. greaterThan m) = {}"

by blast

subsubsection \<open>The Constant @{term atLeast}\<close>

lemma atLeast_0 [simp]: "atLeast (0::nat) = UNIV"

by (unfold atLeast_def UNIV_def, simp)

lemma atLeast_Suc: "atLeast (Suc k) = atLeast k - {k}"

apply (simp add: atLeast_def)

apply (simp add: Suc_le_eq)

apply (simp add: order_le_less, blast)

done

lemma atLeast_Suc_greaterThan: "atLeast (Suc k) = greaterThan k"

  by (auto simp add: greaterThan_def atLeast_def less_Suc_eq_le)

lemma UN_atLeast_UNIV: "(UN m::nat. atLeast m) = UNIV"

by blast

subsubsection \<open>The Constant @{term atMost}\<close>

lemma atMost_0 [simp]: "atMost (0::nat) = {0}"

by (simp add: atMost_def)

lemma atMost_Suc: "atMost (Suc k) = insert (Suc k) (atMost k)"

apply (simp add: atMost_def)

apply (simp add: less_Suc_eq order_le_less, blast)

done

lemma UN_atMost_UNIV: "(UN m::nat. atMost m) = UNIV"

by blast

subsubsection \<open>The Constant @{term atLeastLessThan}\<close>

text\<open>The orientation of the following 2 rules is tricky. The lhs is

defined in terms of the rhs.  Hence the chosen orientation makes sense

in this theory --- the reverse orientation complicates proofs (eg

nontermination). But outside, when the definition of the lhs is rarely

used, the opposite orientation seems preferable because it reduces a

specific concept to a more general one.\<close>

lemma atLeast0LessThan: "{0::nat..<n} = {..<n}"

by(simp add:lessThan_def atLeastLessThan_def)

lemma atLeast0AtMost: "{0..n::nat} = {..n}"

by(simp add:atMost_def atLeastAtMost_def)

declare atLeast0LessThan[symmetric, code_unfold]

        atLeast0AtMost[symmetric, code_unfold]

lemma atLeastLessThan0: "{m..<0::nat} = {}"

by (simp add: atLeastLessThan_def)

subsubsection \<open>Intervals of nats with @{term Suc}\<close>

text\<open>Not a simprule because the RHS is too messy.\<close>

lemma atLeastLessThanSuc:

    "{m..<Suc n} = (if m \<le> n then insert n {m..<n} else {})"

by (auto simp add: atLeastLessThan_def)

lemma atLeastLessThan_singleton [simp]: "{m..<Suc m} = {m}"

by (auto simp add: atLeastLessThan_def)

(*

lemma atLeast_sum_LessThan [simp]: "{m + k..<k::nat} = {}"

by (induct k, simp_all add: atLeastLessThanSuc)

lemma atLeastSucLessThan [simp]: "{Suc n..<n} = {}"

by (auto simp add: atLeastLessThan_def)

*)

lemma atLeastLessThanSuc_atLeastAtMost: "{l..<Suc u} = {l..u}"

  by (simp add: lessThan_Suc_atMost atLeastAtMost_def atLeastLessThan_def)

lemma atLeastSucAtMost_greaterThanAtMost: "{Suc l..u} = {l<..u}"

  by (simp add: atLeast_Suc_greaterThan atLeastAtMost_def

    greaterThanAtMost_def)

lemma atLeastSucLessThan_greaterThanLessThan: "{Suc l..<u} = {l<..<u}"

  by (simp add: atLeast_Suc_greaterThan atLeastLessThan_def

    greaterThanLessThan_def)

lemma atLeastAtMostSuc_conv: "m \<le> Suc n \<Longrightarrow> {m..Suc n} = insert (Suc n) {m..n}"

by (auto simp add: atLeastAtMost_def)

lemma atLeastAtMost_insertL: "m \<le> n \<Longrightarrow> insert m {Suc m..n} = {m ..n}"

by auto

text \<open>The analogous result is useful on @{typ int}:\<close>

(* here, because we don't have an own int section *)

lemma atLeastAtMostPlus1_int_conv:

  "m <= 1+n \<Longrightarrow> {m..1+n} = insert (1+n) {m..n::int}"

  by (auto intro: set_eqI)

lemma atLeastLessThan_add_Un: "i \<le> j \<Longrightarrow> {i..<j+k} = {i..<j} \<union> {j..<j+k::nat}"

  apply (induct k) 

  apply (simp_all add: atLeastLessThanSuc)   

  done

subsubsection \<open>Intervals and numerals\<close>

lemma lessThan_nat_numeral:  --\<open>Evaluation for specific numerals\<close>

  "lessThan (numeral k :: nat) = insert (pred_numeral k) (lessThan (pred_numeral k))"

  by (simp add: numeral_eq_Suc lessThan_Suc)

lemma atMost_nat_numeral:  --\<open>Evaluation for specific numerals\<close>

  "atMost (numeral k :: nat) = insert (numeral k) (atMost (pred_numeral k))"

  by (simp add: numeral_eq_Suc atMost_Suc)

lemma atLeastLessThan_nat_numeral:  --\<open>Evaluation for specific numerals\<close>

  "atLeastLessThan m (numeral k :: nat) = 

     (if m \<le> (pred_numeral k) then insert (pred_numeral k) (atLeastLessThan m (pred_numeral k))

                 else {})"

  by (simp add: numeral_eq_Suc atLeastLessThanSuc)

subsubsection \<open>Image\<close>

lemma image_add_atLeastAtMost [simp]:

  fixes k ::"'a::linordered_semidom"

  shows "(\<lambda>n. n+k) ` {i..j} = {i+k..j+k}" (is "?A = ?B")

proof

  show "?A \<subseteq> ?B" by auto

next

  show "?B \<subseteq> ?A"

  proof

    fix n assume a: "n : ?B"

    hence "n - k : {i..j}"

      by (auto simp: add_le_imp_le_diff add_le_add_imp_diff_le)

    moreover have "n = (n - k) + k" using a

    proof -

      have "k + i \<le> n"

        by (metis a add.commute atLeastAtMost_iff)

      hence "k + (n - k) = n"

        by (metis (no_types) ab_semigroup_add_class.add_ac(1) add_diff_cancel_left' le_add_diff_inverse)

      thus ?thesis

        by (simp add: add.commute)

    qed

    ultimately show "n : ?A" by blast

  qed

qed

lemma image_diff_atLeastAtMost [simp]:

  fixes d::"'a::linordered_idom" shows "(op - d ` {a..b}) = {d-b..d-a}"

  apply auto

  apply (rule_tac x="d-x" in rev_image_eqI, auto)

  done

lemma image_mult_atLeastAtMost [simp]:

  fixes d::"'a::linordered_field"

  assumes "d>0" shows "(op * d ` {a..b}) = {d*a..d*b}"

  using assms

  by (auto simp: field_simps mult_le_cancel_right intro: rev_image_eqI [where x="x/d" for x])

lemma image_affinity_atLeastAtMost:

  fixes c :: "'a::linordered_field"

  shows "((\<lambda>x. m*x + c) ` {a..b}) = (if {a..b}={} then {}

            else if 0 \<le> m then {m*a + c .. m *b + c}

            else {m*b + c .. m*a + c})"

  apply (case_tac "m=0", auto simp: mult_le_cancel_left)

  apply (rule_tac x="inverse m*(x-c)" in rev_image_eqI, auto simp: field_simps)

  apply (rule_tac x="inverse m*(x-c)" in rev_image_eqI, auto simp: field_simps)

  done

lemma image_affinity_atLeastAtMost_diff:

  fixes c :: "'a::linordered_field"

  shows "((\<lambda>x. m*x - c) ` {a..b}) = (if {a..b}={} then {}

            else if 0 \<le> m then {m*a - c .. m*b - c}

            else {m*b - c .. m*a - c})"

  using image_affinity_atLeastAtMost [of m "-c" a b]

  by simp

lemma image_affinity_atLeastAtMost_div_diff:

  fixes c :: "'a::linordered_field"

  shows "((\<lambda>x. x/m - c) ` {a..b}) = (if {a..b}={} then {}

            else if 0 \<le> m then {a/m - c .. b/m - c}

            else {b/m - c .. a/m - c})"

  using image_affinity_atLeastAtMost_diff [of "inverse m" c a b]

  by (simp add: field_class.field_divide_inverse algebra_simps)

lemma image_add_atLeastLessThan:

  "(%n::nat. n+k) ` {i..<j} = {i+k..<j+k}" (is "?A = ?B")

proof

  show "?A \<subseteq> ?B" by auto

next

  show "?B \<subseteq> ?A"

  proof

    fix n assume a: "n : ?B"

    hence "n - k : {i..<j}" by auto

    moreover have "n = (n - k) + k" using a by auto

    ultimately show "n : ?A" by blast

  qed

qed

corollary image_Suc_atLeastAtMost[simp]:

  "Suc ` {i..j} = {Suc i..Suc j}"

using image_add_atLeastAtMost[where k="Suc 0"] by simp

corollary image_Suc_atLeastLessThan[simp]:

  "Suc ` {i..<j} = {Suc i..<Suc j}"

using image_add_atLeastLessThan[where k="Suc 0"] by simp

lemma image_add_int_atLeastLessThan:

    "(%x. x + (l::int)) ` {0..<u-l} = {l..<u}"

  apply (auto simp add: image_def)

  apply (rule_tac x = "x - l" in bexI)

  apply auto

  done

lemma image_minus_const_atLeastLessThan_nat:

  fixes c :: nat

  shows "(\<lambda>i. i - c) ` {x ..< y} =

      (if c < y then {x - c ..< y - c} else if x < y then {0} else {})"

    (is "_ = ?right")

proof safe

  fix a assume a: "a \<in> ?right"

  show "a \<in> (\<lambda>i. i - c) ` {x ..< y}"

  proof cases

    assume "c < y" with a show ?thesis

      by (auto intro!: image_eqI[of _ _ "a + c"])

  next

    assume "\<not> c < y" with a show ?thesis

      by (auto intro!: image_eqI[of _ _ x] split: split_if_asm)

  qed

qed auto

lemma image_int_atLeastLessThan: "int ` {a..<b} = {int a..<int b}"

  by (auto intro!: image_eqI [where x = "nat x" for x])

context ordered_ab_group_add

begin

lemma

  fixes x :: 'a

  shows image_uminus_greaterThan[simp]: "uminus ` {x<..} = {..<-x}"

  and image_uminus_atLeast[simp]: "uminus ` {x..} = {..-x}"

proof safe

  fix y assume "y < -x"

  hence *:  "x < -y" using neg_less_iff_less[of "-y" x] by simp

  have "- (-y) \<in> uminus ` {x<..}"

    by (rule imageI) (simp add: *)

  thus "y \<in> uminus ` {x<..}" by simp

next

  fix y assume "y \<le> -x"

  have "- (-y) \<in> uminus ` {x..}"

    by (rule imageI) (insert \<open>y \<le> -x\<close>[THEN le_imp_neg_le], simp)

  thus "y \<in> uminus ` {x..}" by simp

qed simp_all

lemma

  fixes x :: 'a

  shows image_uminus_lessThan[simp]: "uminus ` {..<x} = {-x<..}"

  and image_uminus_atMost[simp]: "uminus ` {..x} = {-x..}"

proof -

  have "uminus ` {..<x} = uminus ` uminus ` {-x<..}"

    and "uminus ` {..x} = uminus ` uminus ` {-x..}" by simp_all

  thus "uminus ` {..<x} = {-x<..}" and "uminus ` {..x} = {-x..}"

    by (simp_all add: image_image

        del: image_uminus_greaterThan image_uminus_atLeast)

qed

lemma

  fixes x :: 'a

  shows image_uminus_atLeastAtMost[simp]: "uminus ` {x..y} = {-y..-x}"

  and image_uminus_greaterThanAtMost[simp]: "uminus ` {x<..y} = {-y..<-x}"

  and image_uminus_atLeastLessThan[simp]: "uminus ` {x..<y} = {-y<..-x}"

  and image_uminus_greaterThanLessThan[simp]: "uminus ` {x<..<y} = {-y<..<-x}"

  by (simp_all add: atLeastAtMost_def greaterThanAtMost_def atLeastLessThan_def

      greaterThanLessThan_def image_Int[OF inj_uminus] Int_commute)

end

subsubsection \<open>Finiteness\<close>

lemma finite_lessThan [iff]: fixes k :: nat shows "finite {..<k}"

  by (induct k) (simp_all add: lessThan_Suc)

lemma finite_atMost [iff]: fixes k :: nat shows "finite {..k}"

  by (induct k) (simp_all add: atMost_Suc)

lemma finite_greaterThanLessThan [iff]:

  fixes l :: nat shows "finite {l<..<u}"

by (simp add: greaterThanLessThan_def)

lemma finite_atLeastLessThan [iff]:

  fixes l :: nat shows "finite {l..<u}"

by (simp add: atLeastLessThan_def)

lemma finite_greaterThanAtMost [iff]:

  fixes l :: nat shows "finite {l<..u}"

by (simp add: greaterThanAtMost_def)

lemma finite_atLeastAtMost [iff]:

  fixes l :: nat shows "finite {l..u}"

by (simp add: atLeastAtMost_def)

text \<open>A bounded set of natural numbers is finite.\<close>

lemma bounded_nat_set_is_finite:

  "(ALL i:N. i < (n::nat)) ==> finite N"

apply (rule finite_subset)

 apply (rule_tac [2] finite_lessThan, auto)

done