Theory Char_ord

Up to index of Isabelle/HOL/Library

theory Char_ord
imports Product_ord Char_nat

(*  Title:      HOL/Library/Char_ord.thy
Author: Norbert Voelker, Florian Haftmann
*)


header {* Order on characters *}

theory Char_ord
imports Product_ord Char_nat Main
begin


instantiation nibble :: linorder
begin


definition
nibble_less_eq_def: "n ≤ m <-> nat_of_nibble n ≤ nat_of_nibble m"


definition
nibble_less_def: "n < m <-> nat_of_nibble n < nat_of_nibble m"


instance proof
fix n :: nibble
show "n ≤ n" unfolding nibble_less_eq_def nibble_less_def by auto
next
fix n m q :: nibble
assume "n ≤ m"
and "m ≤ q"

then show "n ≤ q" unfolding nibble_less_eq_def nibble_less_def by auto
next
fix n m :: nibble
assume "n ≤ m"
and "m ≤ n"

then show "n = m"
unfolding nibble_less_eq_def nibble_less_def
by (auto simp add: nat_of_nibble_eq)
next
fix n m :: nibble
show "n < m <-> n ≤ m ∧ ¬ m ≤ n"
unfolding nibble_less_eq_def nibble_less_def less_le
by (auto simp add: nat_of_nibble_eq)
next
fix n m :: nibble
show "n ≤ m ∨ m ≤ n"
unfolding nibble_less_eq_def by auto
qed

end

instantiation nibble :: distrib_lattice
begin


definition
"(inf :: nibble => _) = min"


definition
"(sup :: nibble => _) = max"


instance by default (auto simp add:
inf_nibble_def sup_nibble_def min_max.sup_inf_distrib1)


end

instantiation char :: linorder
begin


definition
char_less_eq_def [code del]: "c1 ≤ c2 <-> (case c1 of Char n1 m1 => case c2 of Char n2 m2 =>
n1 < n2 ∨ n1 = n2 ∧ m1 ≤ m2)"


definition
char_less_def [code del]: "c1 < c2 <-> (case c1 of Char n1 m1 => case c2 of Char n2 m2 =>
n1 < n2 ∨ n1 = n2 ∧ m1 < m2)"


instance
by default (auto simp: char_less_eq_def char_less_def split: char.splits)

end

instantiation char :: distrib_lattice
begin


definition
"(inf :: char => _) = min"


definition
"(sup :: char => _) = max"


instance by default (auto simp add:
inf_char_def sup_char_def min_max.sup_inf_distrib1)


end

lemma [simp, code]:
shows char_less_eq_simp: "Char n1 m1 ≤ Char n2 m2 <-> n1 < n2 ∨ n1 = n2 ∧ m1 ≤ m2"
and char_less_simp: "Char n1 m1 < Char n2 m2 <-> n1 < n2 ∨ n1 = n2 ∧ m1 < m2"

unfolding char_less_eq_def char_less_def by simp_all

end