Mercurial > hg > Papers > 2020 > soto-midterm
comparison src/whileTestGears.agda @ 1:73127e0ab57c
(none)
author | soto@cr.ie.u-ryukyu.ac.jp |
---|---|
date | Tue, 08 Sep 2020 18:38:08 +0900 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
0:b919985837a3 | 1:73127e0ab57c |
---|---|
1 module whileTestGears where | |
2 | |
3 open import Function | |
4 open import Data.Nat | |
5 open import Data.Bool hiding ( _≟_ ; _≤?_ ; _≤_ ; _<_) | |
6 open import Data.Product | |
7 open import Level renaming ( suc to succ ; zero to Zero ) | |
8 open import Relation.Nullary using (¬_; Dec; yes; no) | |
9 open import Relation.Binary.PropositionalEquality | |
10 open import Agda.Builtin.Unit | |
11 | |
12 open import utilities | |
13 open _/\_ | |
14 | |
15 -- original codeGear (with non terminatinng ) | |
16 | |
17 record Env : Set (succ Zero) where | |
18 field | |
19 varn : ℕ | |
20 vari : ℕ | |
21 open Env | |
22 | |
23 whileTest : {l : Level} {t : Set l} → (c10 : ℕ) → (Code : Env → t) → t | |
24 whileTest c10 next = next (record {varn = c10 ; vari = 0 } ) | |
25 | |
26 {-# TERMINATING #-} | |
27 whileLoop : {l : Level} {t : Set l} → Env → (Code : Env → t) → t | |
28 whileLoop env next with lt 0 (varn env) | |
29 whileLoop env next | false = next env | |
30 whileLoop env next | true = | |
31 whileLoop (record env {varn = (varn env) - 1 ; vari = (vari env) + 1}) next | |
32 | |
33 test1 : Env | |
34 test1 = whileTest 10 (λ env → whileLoop env (λ env1 → env1 )) | |
35 | |
36 proof1 : whileTest 10 (λ env → whileLoop env (λ e → (vari e) ≡ 10 )) | |
37 proof1 = refl | |
38 | |
39 -- codeGear with pre-condtion and post-condition | |
40 -- | |
41 -- ↓PostCondition | |
42 whileTest' : {l : Level} {t : Set l} → {c10 : ℕ } → (Code : (env : Env ) → ((vari env) ≡ 0) /\ ((varn env) ≡ c10) → t) → t | |
43 whileTest' {_} {_} {c10} next = next env proof2 | |
44 where | |
45 env : Env | |
46 env = record {vari = 0 ; varn = c10 } | |
47 proof2 : ((vari env) ≡ 0) /\ ((varn env) ≡ c10) -- PostCondition | |
48 proof2 = record {pi1 = refl ; pi2 = refl} | |
49 | |
50 | |
51 open import Data.Empty | |
52 open import Data.Nat.Properties | |
53 | |
54 | |
55 {-# TERMINATING #-} -- ↓PreCondition(Invaliant) | |
56 whileLoop' : {l : Level} {t : Set l} → (env : Env ) → {c10 : ℕ } → ((varn env) + (vari env) ≡ c10) → (Code : Env → t) → t | |
57 whileLoop' env proof next with ( suc zero ≤? (varn env) ) | |
58 whileLoop' env proof next | no p = next env | |
59 whileLoop' env {c10} proof next | yes p = whileLoop' env1 (proof3 p ) next | |
60 where | |
61 env1 = record env {varn = (varn env) - 1 ; vari = (vari env) + 1} | |
62 1<0 : 1 ≤ zero → ⊥ | |
63 1<0 () | |
64 proof3 : (suc zero ≤ (varn env)) → varn env1 + vari env1 ≡ c10 | |
65 proof3 (s≤s lt) with varn env | |
66 proof3 (s≤s z≤n) | zero = ⊥-elim (1<0 p) | |
67 proof3 (s≤s (z≤n {n'}) ) | suc n = let open ≡-Reasoning in | |
68 begin | |
69 n' + (vari env + 1) | |
70 ≡⟨ cong ( λ z → n' + z ) ( +-sym {vari env} {1} ) ⟩ | |
71 n' + (1 + vari env ) | |
72 ≡⟨ sym ( +-assoc (n') 1 (vari env) ) ⟩ | |
73 (n' + 1) + vari env | |
74 ≡⟨ cong ( λ z → z + vari env ) +1≡suc ⟩ | |
75 (suc n' ) + vari env | |
76 ≡⟨⟩ | |
77 varn env + vari env | |
78 ≡⟨ proof ⟩ | |
79 c10 | |
80 ∎ | |
81 | |
82 -- Condition to Invariant | |
83 conversion1 : {l : Level} {t : Set l } → (env : Env ) → {c10 : ℕ } → ((vari env) ≡ 0) /\ ((varn env) ≡ c10) | |
84 → (Code : (env1 : Env ) → (varn env1 + vari env1 ≡ c10) → t) → t | |
85 conversion1 env {c10} p1 next = next env proof4 | |
86 where | |
87 proof4 : varn env + vari env ≡ c10 | |
88 proof4 = let open ≡-Reasoning in | |
89 begin | |
90 varn env + vari env | |
91 ≡⟨ cong ( λ n → n + vari env ) (pi2 p1 ) ⟩ | |
92 c10 + vari env | |
93 ≡⟨ cong ( λ n → c10 + n ) (pi1 p1 ) ⟩ | |
94 c10 + 0 | |
95 ≡⟨ +-sym {c10} {0} ⟩ | |
96 c10 | |
97 ∎ | |
98 | |
99 -- all proofs are connected | |
100 proofGears : {c10 : ℕ } → Set | |
101 proofGears {c10} = whileTest' {_} {_} {c10} (λ n p1 → conversion1 n p1 (λ n1 p2 → whileLoop' n1 p2 (λ n2 → ( vari n2 ≡ c10 )))) | |
102 | |
103 -- | |
104 -- codeGear with loop step and closed environment | |
105 -- | |
106 | |
107 open import Relation.Binary | |
108 | |
109 record Envc : Set (succ Zero) where | |
110 field | |
111 c10 : ℕ | |
112 varn : ℕ | |
113 vari : ℕ | |
114 open Envc | |
115 | |
116 whileTestP : {l : Level} {t : Set l} → (c10 : ℕ) → (Code : Envc → t) → t | |
117 whileTestP c10 next = next (record {varn = c10 ; vari = 0 ; c10 = c10 } ) | |
118 | |
119 whileLoopP : {l : Level} {t : Set l} → Envc → (next : Envc → t) → (exit : Envc → t) → t | |
120 whileLoopP env next exit with <-cmp 0 (varn env) | |
121 whileLoopP env next exit | tri≈ ¬a b ¬c = exit env | |
122 whileLoopP env next exit | tri< a ¬b ¬c = | |
123 next (record env {varn = (varn env) - 1 ; vari = (vari env) + 1 }) | |
124 | |
125 -- equivalent of whileLoopP but it looks like an induction on varn | |
126 whileLoopP' : {l : Level} {t : Set l} → (n : ℕ) → (env : Envc) → (n ≡ varn env) → (next : Envc → t) → (exit : Envc → t) → t | |
127 whileLoopP' zero env refl _ exit = exit env | |
128 whileLoopP' (suc n) env refl next _ = next (record {c10 = (c10 env) ; varn = varn env ; vari = suc (vari env) }) | |
129 | |
130 -- normal loop without termination | |
131 {-# TERMINATING #-} | |
132 loopP : {l : Level} {t : Set l} → Envc → (exit : Envc → t) → t | |
133 loopP env exit = whileLoopP env (λ env → loopP env exit ) exit | |
134 | |
135 whileTestPCall : (c10 : ℕ ) → Envc | |
136 whileTestPCall c10 = whileTestP {_} {_} c10 (λ env → loopP env (λ env → env)) | |
137 | |
138 -- | |
139 -- codeGears with states of condition | |
140 -- | |
141 data whileTestState : Set where | |
142 s1 : whileTestState | |
143 s2 : whileTestState | |
144 sf : whileTestState | |
145 | |
146 whileTestStateP : whileTestState → Envc → Set | |
147 whileTestStateP s1 env = (vari env ≡ 0) /\ (varn env ≡ c10 env) | |
148 whileTestStateP s2 env = (varn env + vari env ≡ c10 env) | |
149 whileTestStateP sf env = (vari env ≡ c10 env) | |
150 | |
151 whileTestPwP : {l : Level} {t : Set l} → (c10 : ℕ) → ((env : Envc ) → whileTestStateP s1 env → t) → t | |
152 whileTestPwP c10 next = next env record { pi1 = refl ; pi2 = refl } where | |
153 env : Envc | |
154 env = whileTestP c10 ( λ env → env ) | |
155 | |
156 whileLoopPwP : {l : Level} {t : Set l} → (env : Envc ) → whileTestStateP s2 env | |
157 → (next : (env : Envc ) → whileTestStateP s2 env → t) | |
158 → (exit : (env : Envc ) → whileTestStateP sf env → t) → t | |
159 whileLoopPwP env s next exit with <-cmp 0 (varn env) | |
160 whileLoopPwP env s next exit | tri≈ ¬a b ¬c = exit env (lem (sym b) s) | |
161 where | |
162 lem : (varn env ≡ 0) → (varn env + vari env ≡ c10 env) → vari env ≡ c10 env | |
163 lem refl refl = refl | |
164 whileLoopPwP env s next exit | tri< a ¬b ¬c = next (record env {varn = (varn env) - 1 ; vari = (vari env) + 1 }) (proof5 a) | |
165 where | |
166 1<0 : 1 ≤ zero → ⊥ | |
167 1<0 () | |
168 proof5 : (suc zero ≤ (varn env)) → (varn env - 1) + (vari env + 1) ≡ c10 env | |
169 proof5 (s≤s lt) with varn env | |
170 proof5 (s≤s z≤n) | zero = ⊥-elim (1<0 a) | |
171 proof5 (s≤s (z≤n {n'}) ) | suc n = let open ≡-Reasoning in | |
172 begin | |
173 n' + (vari env + 1) | |
174 ≡⟨ cong ( λ z → n' + z ) ( +-sym {vari env} {1} ) ⟩ | |
175 n' + (1 + vari env ) | |
176 ≡⟨ sym ( +-assoc (n') 1 (vari env) ) ⟩ | |
177 (n' + 1) + vari env | |
178 ≡⟨ cong ( λ z → z + vari env ) +1≡suc ⟩ | |
179 (suc n' ) + vari env | |
180 ≡⟨⟩ | |
181 varn env + vari env | |
182 ≡⟨ s ⟩ | |
183 c10 env | |
184 ∎ | |
185 | |
186 | |
187 whileLoopPwP' : {l : Level} {t : Set l} → (n : ℕ) → (env : Envc ) → (n ≡ varn env) → whileTestStateP s2 env | |
188 → (next : (env : Envc ) → (pred n ≡ varn env) → whileTestStateP s2 env → t) | |
189 → (exit : (env : Envc ) → whileTestStateP sf env → t) → t | |
190 whileLoopPwP' zero env refl refl next exit = exit env refl | |
191 whileLoopPwP' (suc n) env refl refl next exit = next (record env {varn = pred (varn env) ; vari = suc (vari env) }) refl (+-suc n (vari env)) | |
192 | |
193 | |
194 {-# TERMINATING #-} | |
195 loopPwP : {l : Level} {t : Set l} → (env : Envc ) → whileTestStateP s2 env → (exit : (env : Envc ) → whileTestStateP sf env → t) → t | |
196 loopPwP env s exit = whileLoopPwP env s (λ env s → loopPwP env s exit ) exit | |
197 | |
198 | |
199 loopPwP' : {l : Level} {t : Set l} → (n : ℕ) → (env : Envc ) → (n ≡ varn env) → whileTestStateP s2 env → (exit : (env : Envc ) → whileTestStateP sf env → t) → t | |
200 loopPwP' zero env refl refl exit = exit env refl | |
201 loopPwP' (suc n) env refl refl exit = whileLoopPwP' (suc n) env refl refl (λ env x y → loopPwP' n env x y exit) exit | |
202 | |
203 | |
204 loopHelper : (n : ℕ) → (env : Envc ) → (eq : varn env ≡ n) → (seq : whileTestStateP s2 env) → loopPwP' n env (sym eq) seq λ env₁ x → (vari env₁ ≡ c10 env₁) | |
205 loopHelper zero env eq refl rewrite eq = refl | |
206 loopHelper (suc n) env eq refl rewrite eq = loopHelper n (record { c10 = suc (n + vari env) ; varn = n ; vari = suc (vari env) }) refl (+-suc n (vari env)) | |
207 | |
208 | |
209 -- all codtions are correctly connected and required condtion is proved in the continuation | |
210 -- use required condition as t in (env → t) → t | |
211 -- | |
212 whileTestPCallwP : (c : ℕ ) → Set | |
213 whileTestPCallwP c = whileTestPwP {_} {_} c ( λ env s → loopPwP env (conv env s) ( λ env s → vari env ≡ c10 env ) ) where | |
214 conv : (env : Envc ) → (vari env ≡ 0) /\ (varn env ≡ c10 env) → varn env + vari env ≡ c10 env | |
215 conv e record { pi1 = refl ; pi2 = refl } = +zero | |
216 | |
217 | |
218 whileTestPCallwP' : (c : ℕ ) → Set | |
219 whileTestPCallwP' c = whileTestPwP {_} {_} c (λ env s → loopPwP' (varn env) env refl (conv env s) ( λ env s → vari env ≡ c10 env ) ) where | |
220 conv : (env : Envc ) → (vari env ≡ 0) /\ (varn env ≡ c10 env) → varn env + vari env ≡ c10 env | |
221 conv e record { pi1 = refl ; pi2 = refl } = +zero | |
222 | |
223 helperCallwP : (c : ℕ) → whileTestPCallwP' c | |
224 helperCallwP c = whileTestPwP {_} {_} c (λ env s → loopHelper c (record { c10 = c ; varn = c ; vari = zero }) refl +zero) | |
225 | |
226 -- | |
227 -- Using imply relation to make soundness explicit | |
228 -- termination is shown by induction on varn | |
229 -- | |
230 | |
231 data _implies_ (A B : Set ) : Set (succ Zero) where | |
232 proof : ( A → B ) → A implies B | |
233 | |
234 whileTestPSem : (c : ℕ) → whileTestP c ( λ env → ⊤ implies (whileTestStateP s1 env) ) | |
235 whileTestPSem c = proof ( λ _ → record { pi1 = refl ; pi2 = refl } ) | |
236 | |
237 whileTestPSemSound : (c : ℕ ) (output : Envc ) → output ≡ whileTestP c (λ e → e) → ⊤ implies ((vari output ≡ 0) /\ (varn output ≡ c)) | |
238 whileTestPSemSound c output refl = whileTestPSem c | |
239 | |
240 | |
241 whileConvPSemSound : {l : Level} → (input : Envc) → (whileTestStateP s1 input ) implies (whileTestStateP s2 input) | |
242 whileConvPSemSound input = proof λ x → (conv input x) where | |
243 conv : (env : Envc ) → (vari env ≡ 0) /\ (varn env ≡ c10 env) → varn env + vari env ≡ c10 env | |
244 conv e record { pi1 = refl ; pi2 = refl } = +zero | |
245 | |
246 loopPP : (n : ℕ) → (input : Envc ) → (n ≡ varn input) → Envc | |
247 loopPP zero input refl = input | |
248 loopPP (suc n) input refl = | |
249 loopPP n (record input { varn = pred (varn input) ; vari = suc (vari input)}) refl | |
250 | |
251 whileLoopPSem : {l : Level} {t : Set l} → (input : Envc ) → whileTestStateP s2 input | |
252 → (next : (output : Envc ) → (whileTestStateP s2 input ) implies (whileTestStateP s2 output) → t) | |
253 → (exit : (output : Envc ) → (whileTestStateP s2 input ) implies (whileTestStateP sf output) → t) → t | |
254 whileLoopPSem env s next exit with varn env | s | |
255 ... | zero | _ = exit env (proof (λ z → z)) | |
256 ... | (suc varn ) | refl = next ( record env { varn = varn ; vari = suc (vari env) } ) (proof λ x → +-suc varn (vari env) ) | |
257 | |
258 loopPPSem : (input output : Envc ) → output ≡ loopPP (varn input) input refl | |
259 → (whileTestStateP s2 input ) → (whileTestStateP s2 input ) implies (whileTestStateP sf output) | |
260 loopPPSem input output refl s2p = loopPPSemInduct (varn input) input refl refl s2p | |
261 where | |
262 lem : (n : ℕ) → (env : Envc) → n + suc (vari env) ≡ suc (n + vari env) | |
263 lem n env = +-suc (n) (vari env) | |
264 loopPPSemInduct : (n : ℕ) → (current : Envc) → (eq : n ≡ varn current) → (loopeq : output ≡ loopPP n current eq) | |
265 → (whileTestStateP s2 current ) → (whileTestStateP s2 current ) implies (whileTestStateP sf output) | |
266 loopPPSemInduct zero current refl loopeq refl rewrite loopeq = proof (λ x → refl) | |
267 loopPPSemInduct (suc n) current refl loopeq refl rewrite (sym (lem n current)) = | |
268 whileLoopPSem current refl | |
269 (λ output x → loopPPSemInduct n (record { c10 = n + suc (vari current) ; varn = n ; vari = suc (vari current) }) refl loopeq refl) | |
270 (λ output x → loopPPSemInduct n (record { c10 = n + suc (vari current) ; varn = n ; vari = suc (vari current) }) refl loopeq refl) | |
271 | |
272 whileLoopPSemSound : {l : Level} → (input output : Envc ) | |
273 → whileTestStateP s2 input | |
274 → output ≡ loopPP (varn input) input refl | |
275 → (whileTestStateP s2 input ) implies ( whileTestStateP sf output ) | |
276 whileLoopPSemSound {l} input output pre eq = loopPPSem input output eq pre |