Definition Time := nat.
Parameter (Loc : Type) (L_eq : EqDec Loc).
Definition Val := val.
Definition Event := (Loc * Val * Time)%type.
Definition View := Loc -> option Time.
Definition Msg := (Event * View)%type.
Parameters (ThreadId : Type) (T_eq : EqDec ThreadId).
Definition State := (list Msg * (ThreadId -> option View) * View)%type.
Inductive Op := Read_NA (l : Loc) (v : Val) | Read_A (l : Loc) (v : Val)
| Write_NA (l : Loc) (v : Val) | Write_R (l : Loc) (v : Val).
Definition upd {A B} {A_eq : EqDec A} (f : A -> option B) a b c := if eq_dec c a then Some b else f c.
Definition join (V1 V2 : View) l := match V1 l, V2 l with
| Some a, Some b => Some (max a b)
| Some a, _ | _, Some a => Some a
| None, None => None end.
Definition option_le t1 t2 := match t1, t2 with
| Some a, Some b => a <= b
| None, _ => True
| _, None => False end.
Definition option_lt t1 t2 := match t1, t2 with
| Some a, Some b => a < b
| None, _ => True
| _, None => False end.
Inductive step : State -> Op -> ThreadId -> State -> Prop :=
| sRead_A M T N l v t p V Vt (HM : In ((l, v, t), V) M) (Hp : T p = Some Vt) (Ht : option_le (Vt l) (Some t)) :
step (M, T, N) (Read_A l v) p (M, upd T p (join Vt V), N)
| sRead_NA M T N l v t p V Vt (HM : In ((l, v, t), V) M) (Hp : T p = Some Vt) (Ht : option_le (Vt l) (Some t))
(Hlast : forall v' t' V', In ((l, v', t'), V') M -> option_le (Some t') (Vt l)) :
step (M, T, N) (Read_NA l v) p (M, upd T p (join Vt V), N)
| sWrite_R M T N l v t p Vt V' (HM : ~exists v' V, In ((l, v', t), V) M) (Hp : T p = Some Vt)
(HN : option_le (N l) (Vt l))
(Ht : option_lt (Vt l) (Some t)) (HV' : V' = upd Vt l t) :
step (M, T, N) (Write_R l v) p (((l, v, t), V') :: M, upd T p V', N)
| sWrite_NA M T N l v t p Vt V' (HM : ~exists v' V, In ((l, v', t), V) M) (Hp : T p = Some Vt)
(HN : option_le (N l) (Vt l))
(HV' : V' = upd Vt l t) (Ht : forall v' t' V, In ((l, v', t'), V) M -> t' < t) :
step (M, T, N) (Write_NA l v) p (((l, v, t), V') :: M, upd T p V', N).

(* Specifications: *)
Lemma remove_old_NA_write : forall M1 M2 T N l v t V v' t' V' op p M1' M2' T' N'
(Hop : match op with Read_NA _ _ | Write_NA _ _ => True | _ => False end)
(Hin : In ((l, v', t'), V') (M1 ++ M2)) (Hnew : t < t'),
step (M1 ++ ((l, v, t), V) :: M2, T, N) op p (M1' ++ ((l, v, t), V) :: M2', T', N') <->
step (M1 ++ M2, T, N) op p (M1' ++ M2', T', N').