Start working on the evaluation operation.

Proving monotonicity is the main hurdle here.

Signed-off-by: Danila Fedorin <danila.fedorin@gmail.com>

Analysis/Sign.agda

@@ -1,9 +1,11 @@
 module Analysis.Sign where
 
 open import Data.String using (String) renaming (_≟_ to _≟ˢ_)
+open import Data.Nat using (suc)
 open import Data.Product using (_×_; proj₁; _,_)
 open import Data.List using (List; _∷_; []; foldr; cartesianProduct; cartesianProductWith)
-open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; trans)
+open import Data.List.Membership.Propositional as MemProp using () renaming (_∈_ to _∈ˡ_)
+open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; trans; subst)
 open import Relation.Nullary using (¬_; Dec; yes; no)
 open import Data.Unit using (⊤)
 
@@ -108,6 +110,10 @@ module _ (prog : Program) where
             ; _≈_ to _≈ᵛ_
             ; _⊔_ to _⊔ᵛ_
             ; ≈-dec to ≈ᵛ-dec
+            ; _∈_ to _∈ᵛ_
+            ; _∈k_ to _∈kᵛ_
+            ; _updating_via_ to _updatingᵛ_via_
+            ; locate to locateᵛ
             )
     open FiniteHeightLattice finiteHeightLatticeᵛ
         using ()
@@ -129,6 +135,8 @@ module _ (prog : Program) where
             ( finiteHeightLattice to finiteHeightLatticeᵐ
             ; FiniteMap to StateVariables
             ; isLattice to isLatticeᵐ
+            ; _∈k_ to _∈kᵐ_
+            ; locate to locateᵐ
             )
     open FiniteHeightLattice finiteHeightLatticeᵐ
         using ()
@@ -159,3 +167,36 @@ module _ (prog : Program) where
             ( f' to joinAll
             ; f'-Monotonic to joinAll-Mono
             )
+
+    -- With 'join' in hand, we need to perform abstract evaluation.
+
+    vars-in-Map : ∀ (k : String) (vs : VariableSigns) →
+                  k ∈ˡ vars → k ∈kᵛ vs
+    vars-in-Map k vs@(m , kvs≡vars) k∈vars rewrite kvs≡vars = k∈vars
+
+    states-in-Map : ∀ (s : State) (sv : StateVariables) → s ∈kᵐ sv
+    states-in-Map s sv@(m , ksv≡states) rewrite ksv≡states = states-complete s
+
+    eval : ∀ (e : Expr) → (∀ k → k ∈ᵉ e → k ∈ˡ vars) → VariableSigns → SignLattice
+    eval (e₁ + e₂) k∈e⇒k∈vars vs =
+        plus (eval e₁ (λ k k∈e₁ → k∈e⇒k∈vars k (in⁺₁ k∈e₁)) vs)
+             (eval e₂ (λ k k∈e₂ → k∈e⇒k∈vars k (in⁺₂ k∈e₂)) vs)
+    eval (e₁ - e₂) k∈e⇒k∈vars vs =
+        minus (eval e₁ (λ k k∈e₁ → k∈e⇒k∈vars k (in⁻₁ k∈e₁)) vs)
+              (eval e₂ (λ k k∈e₂ → k∈e⇒k∈vars k (in⁻₂ k∈e₂)) vs)
+    eval (` k) k∈e⇒k∈vars vs = proj₁ (locateᵛ {k} {vs} (vars-in-Map k vs (k∈e⇒k∈vars k here)))
+    eval (# 0) _ _ = [ 0ˢ ]ᵍ
+    eval (# (suc n')) _ _ = [ + ]ᵍ
+
+    updateForState : State → StateVariables → VariableSigns
+    updateForState s sv
+        with code s in p
+    ...   | k ← e =
+            let
+                (vs , s,vs∈sv) = locateᵐ {s} {sv} (states-in-Map s sv)
+                k∈e⇒k∈codes = λ k k∈e → subst (λ stmt → k ∈ᵗ stmt) (sym p) (in←₂ k∈e)
+                k∈e⇒k∈vars = λ k k∈e → vars-complete s (k∈e⇒k∈codes k k∈e)
+            in
+                vs updatingᵛ (k ∷ []) via (λ _ → eval e k∈e⇒k∈vars vs)
+
+    -- module Test = StateVariablesFiniteMap.GeneralizedUpdate states isLatticeᵐ joinAll joinAll-Mono