### view whileTestGears1.agda @ 50:2edb44c5bf52

author ryokka Wed, 18 Dec 2019 20:08:58 +0900 b95a3cf9727c
line wrap: on
line source
```
module whileTestGears1 where

open import Function
open import Data.Nat
open import Data.Bool hiding ( _≟_ )
open import Level renaming ( suc to succ ; zero to Zero )
open import Relation.Nullary using (¬_; Dec; yes; no)
open import Relation.Binary.PropositionalEquality

open import utilities
open  _/\_

record Env  : Set where
field
varn : ℕ
vari : ℕ
open Env

whileTest : {l : Level} {t : Set l} -> (c10 : ℕ) → (Code : Env -> t) -> t
whileTest c10 next = next (record {varn = c10 ; vari = 0} )

{-# TERMINATING #-}
whileLoop : {l : Level} {t : Set l} -> Env -> (Code : Env -> t) -> t
whileLoop env next with lt 0 (varn env)
whileLoop env next | false = next env
whileLoop env next | true =
whileLoop (record {varn = (varn env) - 1 ; vari = (vari env) + 1}) next

test1 : Env
test1 = whileTest 10 (λ env → whileLoop env (λ env1 → env1 ))

proof1 : whileTest 10 (λ env → whileLoop env (λ e → (vari e) ≡ 10 ))
proof1 = refl

--                                                                              ↓PostCondition
whileTest' : {l : Level} {t : Set l}  -> {c10 :  ℕ } → (Code : (env : Env)  -> ((vari env) ≡ 0) /\ ((varn env) ≡ c10) -> t) -> t
whileTest' {_} {_} {c10} next = next env proof2
where
env : Env
env = record {vari = 0 ; varn = c10}
proof2 : ((vari env) ≡ 0) /\ ((varn env) ≡ c10) -- PostCondition
proof2 = record {pi1 = refl ; pi2 = refl}

open import Data.Empty
open import Data.Nat.Properties

{-# TERMINATING #-} --                                                  ↓PreCondition(Invaliant)
whileLoop' : {l : Level} {t : Set l} -> (env : Env) -> {c10 :  ℕ } → ((varn env) + (vari env) ≡ c10) -> (Code : Env -> t) -> t
whileLoop' env proof next with  ( suc zero  ≤? (varn  env) )
whileLoop' env proof next | no p = next env
whileLoop' env {c10} proof next | yes p = whileLoop' env1 (proof3 p ) next
where
env1 = record {varn = (varn  env) - 1 ; vari = (vari env) + 1}
1<0 : 1 ≤ zero → ⊥
1<0 ()
proof3 : (suc zero  ≤ (varn  env))  → varn env1 + vari env1 ≡ c10
proof3 (s≤s lt) with varn  env
proof3 (s≤s z≤n) | zero = ⊥-elim (1<0 p)
proof3 (s≤s (z≤n {n'}) ) | suc n =  let open ≡-Reasoning  in
begin
n' + (vari env + 1)
≡⟨ cong ( λ z → n' + z ) ( +-sym  {vari env} {1} )  ⟩
n' + (1 + vari env )
≡⟨ sym ( +-assoc (n')  1 (vari env) ) ⟩
(n' + 1) + vari env
≡⟨ cong ( λ z → z + vari env )  +1≡suc  ⟩
(suc n' ) + vari env
≡⟨⟩
varn env + vari env
≡⟨ proof  ⟩
c10
∎

-- Condition to Invaliant
conversion1 : {l : Level} {t : Set l } → (env : Env) -> {c10 :  ℕ } → ((vari env) ≡ 0) /\ ((varn env) ≡ c10)
-> (Code : (env1 : Env) -> (varn env1 + vari env1 ≡ c10) -> t) -> t
conversion1 env {c10} p1 next = next env proof4
where
proof4 : varn env + vari env ≡ c10
proof4 = let open ≡-Reasoning  in
begin
varn env + vari env
≡⟨ cong ( λ n → n + vari env ) (pi2 p1 ) ⟩
c10 + vari env
≡⟨ cong ( λ n → c10 + n ) (pi1 p1 ) ⟩
c10 + 0
≡⟨ +-sym {c10} {0} ⟩
c10
∎

proofGears : {c10 :  ℕ } → Set
proofGears {c10} = whileTest' {_} {_} {c10} (λ n p1 →  conversion1 n p1 (λ n1 p2 → whileLoop' n1 p2 (λ n2 →  ( vari n2 ≡ c10 ))))

proofGearsMeta : {c10 :  ℕ } → whileTest' {_} {_} {c10} (λ n p1 →  conversion1 n p1 (λ n1 p2 → whileLoop' n1 p2 (λ n2 →  ( vari n2 ≡ c10 ))))
proofGearsMeta {c10} = {!!}

whileTest0 : {l : Level} {t m : Set l} -> (c10 : ℕ) → (Code : m -> Env -> t) -> t
whileTest0 c10 next = next {!!} (record {varn = c10 ; vari = 0} )

{-# TERMINATING #-}
whileLoop0 : {l : Level} {t m : Set l} -> m -> Env -> (Code : m -> Env -> t) -> t
whileLoop0 m env next with lt 0 (varn env)
whileLoop0 m env next | false = next m env
whileLoop0 m env next | true =
whileLoop0 m (record {varn = (varn env) - 1 ; vari = (vari env) + 1}) next

```