Theory Lem_map

chapter ‹Generated by Lem from ‹map.lem›.›

theory "Lem_map" 

imports
  Main
  "Lem_bool"
  "Lem_basic_classes"
  "Lem_function"
  "Lem_maybe"
  "Lem_list"
  "Lem_tuple"
  "Lem_set"
  "Lem_num"

begin 



― ‹‹open import Bool Basic_classes Function Maybe List Tuple Set Num››
― ‹‹open import {hol} `finite_mapTheory` `finite_mapLib`››

― ‹‹type map 'k 'v››



― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Map equality.                                                              ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val mapEqual : forall 'k 'v. Eq 'k, Eq 'v => map 'k 'v -> map 'k 'v -> bool››
― ‹‹val mapEqualBy : forall 'k 'v. ('k -> 'k -> bool) -> ('v -> 'v -> bool) -> map 'k 'v -> map 'k 'v -> bool››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Map type class                                                             ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹class ( MapKeyType 'a )
  val {ocaml;coq} mapKeyCompare : 'a -> 'a -> ordering
end››

― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Empty maps                                                                 ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val empty : forall 'k 'v. MapKeyType 'k => map 'k 'v››
― ‹‹val emptyBy : forall 'k 'v. ('k -> 'k -> ordering) -> map 'k 'v››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Insertion                                                                  ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val insert    : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v -> map 'k 'v››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Singleton                                                                  ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val singleton : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v››



― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Emptyness check                                                            ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val null  : forall 'k 'v. MapKeyType 'k, Eq 'k, Eq 'v => map 'k 'v -> bool››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ lookup                                                                     ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val lookupBy : forall 'k 'v. ('k -> 'k -> ordering) -> 'k -> map 'k 'v -> maybe 'v››

― ‹‹val lookup          : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> maybe 'v››

― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ findWithDefault                                                            ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val findWithDefault : forall 'k 'v. MapKeyType 'k => 'k -> 'v -> map 'k 'v -> 'v››

― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ from lists                                                                 ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val fromList  : forall 'k 'v. MapKeyType 'k => list ('k * 'v) -> map 'k 'v››
― ‹‹let fromList l=  foldl (fun m (k,v) -> insert k v m) empty l››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ to sets / domain / range                                                   ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val toSet : forall 'k 'v. MapKeyType 'k, SetType 'k, SetType 'v => map 'k 'v -> set ('k * 'v)›› 
― ‹‹val toSetBy : forall 'k 'v. (('k * 'v) -> ('k * 'v) -> ordering) -> map 'k 'v -> set ('k * 'v)››


― ‹‹val domainBy : forall 'k 'v. ('k -> 'k -> ordering) -> map 'k 'v -> set 'k››
― ‹‹val domain : forall 'k 'v. MapKeyType 'k, SetType 'k => map 'k 'v -> set 'k››


― ‹‹val range : forall 'k 'v. MapKeyType 'k, SetType 'v => map 'k 'v -> set 'v››
― ‹‹val rangeBy : forall 'k 'v. ('v -> 'v -> ordering) -> map 'k 'v -> set 'v››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ member                                                                     ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val member          : forall 'k 'v. MapKeyType 'k, SetType 'k, Eq 'k => 'k -> map 'k 'v -> bool››

― ‹‹val notMember       : forall 'k 'v. MapKeyType 'k, SetType 'k, Eq 'k => 'k -> map 'k 'v -> bool››

― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Quantification                                                             ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val any : forall 'k 'v. MapKeyType 'k, Eq 'v => ('k -> 'v -> bool) -> map 'k 'v -> bool›› 
― ‹‹val all : forall 'k 'v. MapKeyType 'k, Eq 'v => ('k -> 'v -> bool) -> map 'k 'v -> bool›› 

― ‹‹let all P m=  (forall k v. (P k v && ((Instance_Basic_classes_Eq_Maybe_maybe.=) (lookup k m) (Just v))))››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Set-like operations.                                                       ››
― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹val deleteBy         : forall 'k 'v. ('k -> 'k -> ordering) -> 'k -> map 'k 'v -> map 'k 'v››
― ‹‹val delete           : forall 'k 'v. MapKeyType 'k => 'k -> map 'k 'v -> map 'k 'v››
― ‹‹val deleteSwap      : forall 'k 'v. MapKeyType 'k => map 'k 'v -> 'k -> map 'k 'v››

― ‹‹val union          : forall 'k 'v. MapKeyType 'k => map 'k 'v -> map 'k 'v -> map 'k 'v››

― ‹‹val unions           : forall 'k 'v. MapKeyType 'k => list (map 'k 'v) -> map 'k 'v››


― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Maps (in the functor sense).                                               ››
― ‹‹ -------------------------------------------------------------------------- ››

― ‹‹val map             : forall 'k 'v 'w. MapKeyType 'k => ('v -> 'w) -> map 'k 'v -> map 'k 'w››

― ‹‹val mapi : forall 'k 'v 'w. MapKeyType 'k => ('k -> 'v -> 'w) -> map 'k 'v -> map 'k 'w››

― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹ Cardinality                                                                ››
― ‹‹ -------------------------------------------------------------------------- ››
― ‹‹val size  : forall 'k 'v. MapKeyType 'k, SetType 'k => map 'k 'v -> nat››

― ‹‹ instance of SetType ››
definition map_setElemCompare  :: "(('d*'c)set ⇒('b*'a)set ⇒ 'e)⇒('d,'c)Map.map ⇒('b,'a)Map.map ⇒ 'e "  where 
     " map_setElemCompare cmp x y = (
  cmp (map_to_set x) (map_to_set y))"

end