Module Exports.
Section Exports.
Variables (K : ordType) (V : eqType) (p : pred K).
Variables (T : Type) (m : @UMC.mixin_of K V p T).
Definition union_map_class_eqMix := EqMixin (@unionmap_eqP K V p T m).
End Exports.
End Exports.
End UnionMapEq.
Export UnionMapEq.Exports.
(*******)
(* dom *)
(*******)
Section DomLemmas.
Variables (K : ordType) (V : Type) (U : union_map_class K V).
Implicit Types (k : K) (v : V) (f g : U).

(* Specifications: *)
Lemma dom_undef : dom (um_undef : U) = [::].
Lemma domU k v f :
dom (upd k v f) =i
[pred x | cond U k & if x == k then valid f else x \in dom f].
Lemma domF k f :
dom (free k f) =i
[pred x | if k == x then false else x \in dom f].
Lemma domUn f1 f2 :
dom (f1 \+ f2) =i
[pred x | valid (f1 \+ f2) & (x \in dom f1) || (x \in dom f2)].
Lemma dom_valid k f : k \in dom f -> valid f.
CoInductive dom_find_spec k f : bool -> Type :=
| dom_find_none' : find k f = None -> dom_find_spec k f false
| dom_find_some' v : find k f = Some v ->
f = upd k v (free k f) -> dom_find_spec k f true.
Lemma dom_find k f : dom_find_spec k f (k \in dom f).
Lemma find_some k v f : find k f = Some v -> k \in dom f.
Lemma dom_prec f1 f2 g1 g2 :
valid (f1 \+ g1) ->
f1 \+ g1 = f2 \+ g2 ->
dom f1 =i dom f2 -> f1 = f2.
Lemma domK f1 f2 g1 g2 :
valid (f1 \+ g1) -> valid (f2 \+ g2) ->
dom (f1 \+ g1) =i dom (f2 \+ g2) ->
dom f1 =i dom f2 -> dom g1 =i dom g2.
Lemma umfilt_dom f1 f2 :
valid (f1 \+ f2) -> um_filter (mem (dom f1)) (f1 \+ f2) = f1.
Lemma sorted_dom f : sorted (@ord K) (dom f).
Lemma perm_domUn f1 f2 :
valid (f1 \+ f2) -> perm_eq (dom (f1 \+ f2)) (dom f1 ++ dom f2).
Lemma size_domUn f1 f2 :
valid (f1 \+ f2) ->
size (dom (f1 \+ f2)) = size (dom f1) + size (dom f2).
Lemma umfilt0 q : um_filter q Unit = Unit :> U.
Lemma umfilt_pred0 f : valid f -> um_filter pred0 f = Unit.
Lemma umfilt_predT f : um_filter predT f = f.
Lemma umfilt_predI p1 p2 f :
um_filter (predI p1 p2) f = um_filter p1 (um_filter p2 f).
Lemma umfilt_predU p1 p2 f :
um_filter (predU p1 p2) f =
um_filter p1 f \+ um_filter (predD p2 p1) f.
Lemma umfilt_dpredU f p q :
{subset p <= predC q} ->
um_filter (predU p q) f = um_filter p f \+ um_filter q f.
Lemma umfiltUnK p f1 f2 :
valid (f1 \+ f2) ->
um_filter p (f1 \+ f2) = f1 ->
um_filter p f1 = f1 /\ um_filter p f2 = Unit.
Lemma umfiltU p k v f :
um_filter p (upd k v f) =
if p k then upd k v (um_filter p f) else
if cond U k then um_filter p f else um_undef.
Lemma umfiltF p k f :
um_filter p (free k f) =
if p k then free k (um_filter p f) else um_filter p f.