IntervalValidation.v 23.5 KB
Newer Older
Heiko Becker's avatar
Heiko Becker committed
1
(**
Heiko Becker's avatar
Heiko Becker committed
2 3 4 5 6
    Interval arithmetic checker and its soundness proof.
    The function validIntervalbounds checks wether the given analysis result is
    a valid range arithmetic for each sub term of the given expression e.
    The computation is done using our formalized interval arithmetic.
    The function is used in CertificateChecker.v to build the full checker.
Heiko Becker's avatar
Heiko Becker committed
7
**)
8
Require Import Coq.QArith.QArith Coq.QArith.Qreals QArith.Qminmax Coq.Lists.List Coq.micromega.Psatz.
9
Require Import Daisy.Infra.Abbrevs Daisy.Infra.RationalSimps Daisy.Infra.RealRationalProps.
10 11
Require Import Daisy.Infra.Ltacs Daisy.Infra.RealSimps.
Require Export Daisy.IntervalArithQ Daisy.IntervalArith Daisy.ssaPrgs.
12

13
Fixpoint validIntervalbounds (e:exp Q) (absenv:analysisResult) (P:precond) (validVars:NatSet.t) :=
14 15
  let (intv, _) := absenv e in
    match e with
16
    | Var _ v => if NatSet.mem v validVars then true else isSupersetIntv (P v) intv
Heiko Becker's avatar
Heiko Becker committed
17 18
    | Const n => isSupersetIntv (n,n) intv
    | Unop o f =>
19
    let rec := validIntervalbounds f absenv P validVars in
Heiko Becker's avatar
Heiko Becker committed
20
    let (iv, _) := absenv f in
21
    let opres :=
Heiko Becker's avatar
Heiko Becker committed
22
        match o with
23
        | Neg =>
Heiko Becker's avatar
Heiko Becker committed
24
          let new_iv := negateIntv iv in
25 26 27
          isSupersetIntv new_iv intv
        | Inv =>
          let nodiv0 := orb
Heiko Becker's avatar
Heiko Becker committed
28 29 30
                          (andb (Qleb (ivhi iv) 0) (negb (Qeq_bool (ivhi iv) 0)))
                          (andb (Qleb 0 (ivlo iv)) (negb (Qeq_bool (ivlo iv) 0))) in
          let new_iv := invertIntv iv in
31
          andb (isSupersetIntv new_iv intv) nodiv0
Heiko Becker's avatar
Heiko Becker committed
32 33
        end
    in
34
    andb rec opres
Heiko Becker's avatar
Heiko Becker committed
35
    | Binop op f1 f2 =>
36
      let rec := andb (validIntervalbounds f1 absenv P validVars) (validIntervalbounds f2 absenv P validVars) in
Heiko Becker's avatar
Heiko Becker committed
37 38
      let (iv1,_) := absenv f1 in
      let (iv2,_) := absenv f2 in
39
      let opres :=
Heiko Becker's avatar
Heiko Becker committed
40
          match op with
41 42 43 44 45 46 47 48 49
          | Plus =>
            let new_iv := addIntv iv1 iv2 in
            isSupersetIntv new_iv intv
          | Sub =>
            let new_iv := subtractIntv iv1 iv2 in
            isSupersetIntv new_iv intv
          | Mult =>
            let new_iv := multIntv iv1 iv2 in
            isSupersetIntv new_iv intv
Heiko Becker's avatar
Heiko Becker committed
50
          | Div =>
51 52 53
            let nodiv0 := orb
                            (andb (Qleb (ivhi iv2) 0) (negb (Qeq_bool (ivhi iv2) 0)))
                            (andb (Qleb 0 (ivlo iv2)) (negb (Qeq_bool (ivlo iv2) 0))) in
Heiko Becker's avatar
Heiko Becker committed
54
            let new_iv := divideIntv iv1 iv2 in
55
            andb (isSupersetIntv new_iv intv) nodiv0
56 57 58 59 60
          end
      in
      andb rec opres
    end.

61
Fixpoint validIntervalboundsCmd (f:cmd Q) (absenv:analysisResult) (P:precond) (validVars:NatSet.t) :bool:=
62
  match f with
63
  | Let x e g =>
64 65 66 67
    validIntervalbounds e absenv P validVars &&
                        (Qeq_bool (fst (fst (absenv e))) (fst (fst (absenv (Var Q x)))) &&
                                  Qeq_bool (snd (fst (absenv e))) (snd (fst (absenv (Var Q x))))) &&
                        validIntervalboundsCmd g absenv P (NatSet.add x validVars)
68 69
  |Ret e =>
   validIntervalbounds e absenv P validVars
70 71 72 73
  end.

Theorem ivbounds_approximatesPrecond_sound f absenv P V:
  validIntervalbounds f absenv P V = true ->
74 75
  forall v, NatSet.In v (NatSet.diff (Expressions.freeVars f) V) ->
       Is_true(isSupersetIntv (P v) (fst (absenv (Var Q v)))).
76
Proof.
Heiko Becker's avatar
Heiko Becker committed
77
  induction f; unfold validIntervalbounds.
78
  - intros approx_true v v_in_fV; simpl in *.
79 80 81 82 83 84 85 86 87 88 89
    rewrite NatSet.diff_spec in v_in_fV.
    rewrite NatSet.singleton_spec in v_in_fV;
      destruct v_in_fV; subst.
    destruct (absenv (Var Q n)); simpl in *.
    case_eq (NatSet.mem n V); intros case_mem;
      rewrite case_mem in approx_true; simpl in *.
    + rewrite NatSet.mem_spec in case_mem.
      contradiction.
    + apply Is_true_eq_left in approx_true; auto.
  - intros approx_true v0 v_in_fV; simpl in *.
    inversion v_in_fV.
Heiko Becker's avatar
Heiko Becker committed
90 91 92 93 94 95 96 97
  - intros approx_unary_true v v_in_fV.
    unfold freeVars in v_in_fV.
    apply Is_true_eq_left in approx_unary_true.
    destruct (absenv (Unop u f)); destruct (absenv f); simpl in *.
    apply andb_prop_elim in approx_unary_true.
    destruct approx_unary_true.
    apply IHf; try auto.
    apply Is_true_eq_true; auto.
98
  - intros approx_bin_true v v_in_fV.
99 100 101 102
    simpl in v_in_fV.
    rewrite NatSet.diff_spec in v_in_fV.
    destruct v_in_fV as [ v_in_fV v_not_in_V].
    rewrite NatSet.union_spec in v_in_fV.
103
    apply Is_true_eq_left in approx_bin_true.
Heiko Becker's avatar
Heiko Becker committed
104
    destruct (absenv (Binop b f1 f2)); destruct (absenv f1); destruct (absenv f2); simpl in *.
105 106 107 108
    apply andb_prop_elim in approx_bin_true.
    destruct approx_bin_true.
    apply andb_prop_elim in H.
    destruct H.
109
    destruct v_in_fV.
Heiko Becker's avatar
Heiko Becker committed
110
    + apply IHf1; auto.
111
      apply Is_true_eq_true; auto.
112
      rewrite NatSet.diff_spec; split; auto.
Heiko Becker's avatar
Heiko Becker committed
113
    + apply IHf2; auto.
114
      apply Is_true_eq_true; auto.
115
      rewrite NatSet.diff_spec; split; auto.
116 117
Qed.

Heiko Becker's avatar
Heiko Becker committed
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
Corollary Q2R_max4 a b c d:
  Q2R (IntervalArithQ.max4 a b c d) = max4 (Q2R a) (Q2R b) (Q2R c) (Q2R d).
Proof.
  unfold IntervalArithQ.max4, max4; repeat rewrite Q2R_max; auto.
Qed.

Corollary Q2R_min4 a b c d:
  Q2R (IntervalArithQ.min4 a b c d) = min4 (Q2R a) (Q2R b) (Q2R c) (Q2R d).
Proof.
  unfold IntervalArith.min4, min4; repeat rewrite Q2R_min; auto.
Qed.

Ltac env_assert absenv e name :=
  assert (exists iv err, absenv e = (iv,err)) as name by (destruct (absenv e); repeat eexists; auto).

133
Lemma validBoundsDiv_uneq_zero e1 e2 absenv P V ivlo_e2 ivhi_e2 err:
134
  absenv e2 = ((ivlo_e2,ivhi_e2), err) ->
135
  validIntervalbounds (Binop Div e1 e2) absenv P V = true ->
136 137 138 139 140 141 142 143 144 145 146
  (ivhi_e2 < 0) \/ (0 < ivlo_e2).
Proof.
  intros absenv_eq validBounds.
  unfold validIntervalbounds in validBounds.
  env_assert absenv (Binop Div e1 e2) abs_div; destruct abs_div as [iv_div [err_div abs_div]].
  env_assert absenv e1 abs_e1; destruct abs_e1 as [iv_e1 [err_e1 abs_e1]].
  rewrite abs_div, abs_e1, absenv_eq in validBounds.
  apply Is_true_eq_left in validBounds.
  apply andb_prop_elim in validBounds.
  destruct validBounds as [_ validBounds]; apply andb_prop_elim in validBounds.
  destruct validBounds as [_ nodiv0].
147 148
  apply Is_true_eq_true in nodiv0.
  apply le_neq_bool_to_lt_prop; auto.
149 150
Qed.

151 152 153 154 155 156 157
Fixpoint getRetExp (V:Type) (f:cmd V) :=
  match f with
  |Let x e g => getRetExp g
  | Ret e => e
  end.

Theorem validIntervalbounds_sound (f:exp Q) (absenv:analysisResult) (P:precond) V E:
Heiko Becker's avatar
Heiko Becker committed
158
  forall vR,
159 160
    validIntervalbounds f absenv P V = true ->
    (forall v, NatSet.mem v V = true ->
161
          exists vR, E v = Some vR /\
162 163 164 165 166
                (Q2R (fst (fst (absenv (Var Q v)))) <= vR <= Q2R (snd (fst (absenv (Var Q v)))))%R) ->
    (forall v, NatSet.mem v (NatSet.diff (Expressions.freeVars f) V)= true ->
          exists vR, E v = Some vR /\
                (Q2R (fst (P v)) <= vR <= Q2R (snd (P v)))%R) ->
    eval_exp 0%R E (toRExp f) vR ->
Heiko Becker's avatar
Heiko Becker committed
167
  (Q2R (fst (fst(absenv f))) <= vR <= Q2R (snd (fst (absenv f))))%R.
168
Proof.
169
  induction f; intros vR valid_bounds valid_definedVars valid_freeVars eval_f.
170 171 172 173 174 175
  - unfold validIntervalbounds in valid_bounds.
    env_assert absenv (Var Q n) absenv_var.
    destruct absenv_var as [ iv [err absenv_var]].
    specialize (valid_freeVars n).
    rewrite absenv_var in *; simpl in *.
    inversion eval_f; subst.
176
    case_eq (NatSet.mem n V); intros case_mem; rewrite case_mem in *; simpl in *.
177 178
    + specialize (valid_definedVars n case_mem).
      destruct valid_definedVars as [vR' [E_n_eq precond_sound]].
179 180
      rewrite E_n_eq in *.
      inversion H0; subst.
181
      rewrite absenv_var in *; auto.
182 183 184 185 186 187 188 189
    + repeat (rewrite delta_0_deterministic in *; try auto).
      unfold isSupersetIntv in valid_bounds.
      andb_to_prop valid_bounds.
      apply Qle_bool_iff in L;
        apply Qle_bool_iff in R.
      apply Qle_Rle in L;
        apply Qle_Rle in R.
      simpl in *.
190 191 192 193 194 195 196 197 198 199 200
      assert (NatSet.mem n (NatSet.diff (NatSet.singleton n) V) = true).
      * rewrite NatSet.mem_spec, NatSet.diff_spec, NatSet.singleton_spec.
        split; try auto.
        hnf; intros mem_V.
        rewrite <- NatSet.mem_spec in mem_V;
          rewrite mem_V in case_mem.
        inversion case_mem.
      * specialize (valid_freeVars H);
          destruct valid_freeVars as [vR' [vR_def P_valid]].
        rewrite vR_def in H0; inversion H0; subst.
        lra.
201
  - unfold validIntervalbounds in valid_bounds.
Heiko Becker's avatar
Heiko Becker committed
202
    destruct (absenv (Const v)) as [intv err]; simpl.
203 204
    apply Is_true_eq_left in valid_bounds.
    apply andb_prop_elim in valid_bounds.
Heiko Becker's avatar
Heiko Becker committed
205
    destruct valid_bounds as [valid_lo valid_hi].
Heiko Becker's avatar
Heiko Becker committed
206
    inversion eval_f; subst.
207
    rewrite delta_0_deterministic; auto.
208 209
    unfold contained; simpl.
    split.
Heiko Becker's avatar
Heiko Becker committed
210
    + apply Is_true_eq_true in valid_lo.
211
      unfold Qleb in *.
Heiko Becker's avatar
Heiko Becker committed
212 213 214 215 216 217
      apply Qle_bool_iff in valid_lo.
      apply Qle_Rle in valid_lo; auto.
    + apply Is_true_eq_true in valid_hi.
      unfold Qleb in *.
      apply Qle_bool_iff in valid_hi.
      apply Qle_Rle in valid_hi; auto.
218
  - case_eq (absenv (Unop u f)); intros intv err absenv_unop.
Heiko Becker's avatar
Heiko Becker committed
219 220 221 222 223 224 225 226 227 228
    destruct intv as [unop_lo unop_hi]; simpl.
    unfold validIntervalbounds in valid_bounds.
    rewrite absenv_unop in valid_bounds.
    case_eq (absenv f); intros intv_f err_f absenv_f.
    rewrite absenv_f in valid_bounds.
    apply Is_true_eq_left in valid_bounds.
    apply andb_prop_elim in valid_bounds.
    destruct valid_bounds as [valid_rec valid_unop].
    apply Is_true_eq_true in valid_rec.
    inversion eval_f; subst.
229
    + specialize (IHf v1 valid_rec valid_definedVars valid_freeVars H2).
Heiko Becker's avatar
Heiko Becker committed
230
      rewrite absenv_f in IHf; simpl in IHf.
231 232 233 234 235 236
      (* TODO: Make lemma *)
      unfold isSupersetIntv in valid_unop.
      apply andb_prop_elim in valid_unop.
      destruct valid_unop as [valid_lo valid_hi].
      apply Is_true_eq_true in valid_lo; apply Is_true_eq_true in valid_hi.
      apply Qle_bool_iff in valid_lo; apply Qle_bool_iff in valid_hi.
237
      pose proof (interval_negation_valid (iv :=(Q2R (fst intv_f),(Q2R (snd intv_f)))) (a :=v1)) as negation_valid.
238 239 240
      unfold contained, negateInterval in negation_valid; simpl in *.
      apply Qle_Rle in valid_lo; apply Qle_Rle in valid_hi.
      destruct IHf.
241
      split.
242 243 244 245 246
      * eapply Rle_trans. apply valid_lo.
        rewrite Q2R_opp; lra.
      * eapply Rle_trans.
        Focus 2. apply valid_hi.
        rewrite Q2R_opp; lra.
247
    + specialize (IHf v1 valid_rec valid_definedVars valid_freeVars H3).
Heiko Becker's avatar
Heiko Becker committed
248
      rewrite absenv_f in IHf; simpl in IHf.
249 250 251 252 253 254 255 256 257 258 259 260 261 262
      apply andb_prop_elim in valid_unop.
      destruct valid_unop as [valid_unop nodiv0].
      (* TODO: Make lemma *)
      unfold isSupersetIntv in valid_unop.
      apply andb_prop_elim in valid_unop.
      destruct valid_unop as [valid_lo valid_hi].
      apply Is_true_eq_true in valid_lo; apply Is_true_eq_true in valid_hi.
      apply Qle_bool_iff in valid_lo; apply Qle_bool_iff in valid_hi.
      assert ((Q2R (ivhi intv_f) < 0)%R \/ (0 < Q2R (ivlo intv_f))%R) as nodiv0_prop.
       * apply Is_true_eq_true in nodiv0.
         apply le_neq_bool_to_lt_prop in nodiv0.
         destruct nodiv0.
         { left; rewrite <- Q2R0_is_0; apply Qlt_Rlt; auto. }
         { right; rewrite <- Q2R0_is_0; apply Qlt_Rlt; auto. }
263
       * pose proof (interval_inversion_valid (iv :=(Q2R (fst intv_f),(Q2R (snd intv_f)))) (a :=v1)) as inv_valid.
264 265 266
         unfold contained, invertInterval in inv_valid; simpl in *.
         apply Qle_Rle in valid_lo; apply Qle_Rle in valid_hi.
         destruct IHf.
267
         rewrite delta_0_deterministic; auto.
268
         unfold perturb; split.
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
         { eapply Rle_trans. apply valid_lo.
           destruct nodiv0_prop as [nodiv0_neg | nodiv0_pos].
           (* TODO: Extract lemma maybe *)
           - assert (0 < - (Q2R (snd intv_f)))%R as negation_pos by lra.
             assert (- (Q2R (snd intv_f)) <= - v1)%R as negation_flipped_hi by lra.
             apply Rinv_le_contravar in negation_flipped_hi; try auto.
             rewrite <- Ropp_inv_permute in negation_flipped_hi; try lra.
             rewrite <- Ropp_inv_permute in negation_flipped_hi; try lra.
             apply Ropp_le_contravar in negation_flipped_hi.
             repeat rewrite Ropp_involutive in negation_flipped_hi;
               rewrite Q2R_inv; auto.
             hnf; intros is_0.
             rewrite <- Q2R0_is_0 in nodiv0_neg.
             apply Rlt_Qlt in nodiv0_neg; lra.
           - rewrite Q2R_inv.
             apply Rinv_le_contravar; try lra.
             hnf; intros is_0.
             assert (Q2R (fst intv_f) <= Q2R (snd intv_f))%R by lra.
             rewrite <- Q2R0_is_0 in nodiv0_pos.
             apply Rlt_Qlt in nodiv0_pos; apply Rle_Qle in H2; lra.
         }
         { eapply Rle_trans.
           Focus 2. apply valid_hi.
           destruct nodiv0_prop as [nodiv0_neg | nodiv0_pos].
           - assert (Q2R (fst intv_f) < 0)%R as fst_lt_0 by lra.
             assert (0 < - (Q2R (fst intv_f)))%R as negation_pos by lra.
             assert (- v1 <= - (Q2R (fst intv_f)))%R as negation_flipped_lo by lra.
             apply Rinv_le_contravar in negation_flipped_lo; try auto.
             rewrite <- Ropp_inv_permute in negation_flipped_lo; try lra.
             rewrite <- Ropp_inv_permute in negation_flipped_lo; try lra.
             apply Ropp_le_contravar in negation_flipped_lo.
             repeat rewrite Ropp_involutive in negation_flipped_lo;
               rewrite Q2R_inv; auto.
             hnf; intros is_0.
             rewrite <- Q2R0_is_0 in negation_pos.
             rewrite <- Q2R_opp in negation_pos.
             apply Rlt_Qlt in negation_pos; lra.
             assert (0 < - (Q2R (snd intv_f)))%R by lra.
             lra.
           - rewrite Q2R_inv.
             apply Rinv_le_contravar; try lra.
             hnf; intros is_0.
             assert (Q2R (fst intv_f) <= Q2R (snd intv_f))%R by lra.
             rewrite <- Q2R0_is_0 in nodiv0_pos.
             apply Rlt_Qlt in nodiv0_pos; apply Rle_Qle in H2; lra.
         }
315
  - inversion eval_f; subst.
316 317
    rewrite delta_0_deterministic in eval_f; auto.
    rewrite delta_0_deterministic; auto.
Heiko Becker's avatar
Heiko Becker committed
318
    simpl in valid_bounds.
Heiko Becker's avatar
Heiko Becker committed
319 320 321 322
    case_eq (absenv (Binop b f1 f2)); intros iv err absenv_bin.
    case_eq (absenv f1); intros iv1 err1 absenv_f1.
    case_eq (absenv f2); intros iv2 err2 absenv_f2.
    rewrite absenv_bin, absenv_f1, absenv_f2 in valid_bounds.
Heiko Becker's avatar
Heiko Becker committed
323 324 325 326 327 328
    apply Is_true_eq_left in valid_bounds.
    apply andb_prop_elim in valid_bounds.
    destruct valid_bounds as [valid_rec valid_bin].
    apply andb_prop_elim in valid_rec.
    destruct valid_rec as [valid_e1 valid_e2].
    apply Is_true_eq_true in valid_e1; apply Is_true_eq_true in  valid_e2.
329 330
    specialize (IHf1 v1 valid_e1 valid_definedVars);
      specialize (IHf2 v2 valid_e2 valid_definedVars).
Heiko Becker's avatar
Heiko Becker committed
331 332
    rewrite absenv_f1 in IHf1.
    rewrite absenv_f2 in IHf2.
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    assert ((Q2R (fst (fst (iv1, err1))) <= v1 <= Q2R (snd (fst (iv1, err1))))%R) as valid_bounds_e1.
    + apply IHf1; try auto.
      intros v in_diff_e1.
      apply valid_freeVars.
      rewrite NatSet.mem_spec, NatSet.diff_spec in *.
      simpl.
      destruct in_diff_e1; split; try auto.
      rewrite NatSet.union_spec; auto.
    + assert (Q2R (fst (fst (iv2, err2))) <= v2 <= Q2R (snd (fst (iv2, err2))))%R as valid_bounds_e2.
      * apply IHf2; try auto.
        intros v in_diff_e2.
        apply valid_freeVars.
        rewrite NatSet.mem_spec, NatSet.diff_spec in *.
        simpl.
        destruct in_diff_e2; split; try auto.
        rewrite NatSet.union_spec; auto.
      * destruct b; simpl in *.
        { pose proof (interval_addition_valid (iv1 :=(Q2R (fst iv1),Q2R (snd iv1))) (iv2 :=(Q2R (fst iv2), Q2R (snd iv2)))) as valid_add.
          unfold validIntervalAdd in valid_add.
          specialize (valid_add v1 v2 valid_bounds_e1 valid_bounds_e2).
          unfold contained in valid_add.
          unfold isSupersetIntv in valid_bin.
          apply andb_prop_elim in valid_bin; destruct valid_bin as [valid_lo valid_hi].
          apply Is_true_eq_true in valid_lo; apply Is_true_eq_true in valid_hi.
          apply Qle_bool_iff in valid_lo; apply Qle_bool_iff in valid_hi.
          apply Qle_Rle in valid_lo; apply Qle_Rle in valid_hi.
          destruct valid_add as [valid_add_lo valid_add_hi].
          split.
          - eapply Rle_trans. apply valid_lo.
            unfold ivlo. unfold addIntv.
            simpl in valid_add_lo.
            repeat rewrite <- Q2R_plus in valid_add_lo.
            rewrite <- Q2R_min4 in valid_add_lo.
            unfold absIvUpd; auto.
          - eapply Rle_trans.
            Focus 2.
            apply valid_hi.
            unfold ivlo, addIntv.
            simpl in valid_add_hi.
            repeat rewrite <- Q2R_plus in valid_add_hi.
            rewrite <- Q2R_max4 in valid_add_hi.
            unfold absIvUpd; auto. }
        { pose proof (interval_subtraction_valid (iv1 := (Q2R (fst iv1),Q2R (snd iv1))) (iv2 :=(Q2R (fst iv2), Q2R (snd iv2)))) as valid_sub.
          specialize (valid_sub v1 v2 valid_bounds_e1 valid_bounds_e2).
          unfold contained in valid_sub.
          unfold isSupersetIntv in valid_bin.
          apply andb_prop_elim in valid_bin; destruct valid_bin as [valid_lo valid_hi].
          apply Is_true_eq_true in valid_lo; apply Is_true_eq_true in valid_hi.
          apply Qle_bool_iff in valid_lo; apply Qle_bool_iff in valid_hi.
          apply Qle_Rle in valid_lo; apply Qle_Rle in valid_hi.
          destruct valid_sub as [valid_sub_lo valid_sub_hi].
          split.
          - eapply Rle_trans. apply valid_lo.
            unfold ivlo. unfold subtractIntv.
            simpl in valid_sub_lo.
            repeat rewrite <- Rsub_eq_Ropp_Rplus in valid_sub_lo.
            repeat rewrite <- Q2R_minus in valid_sub_lo.
            rewrite <- Q2R_min4 in valid_sub_lo.
            unfold absIvUpd; auto.
          - eapply Rle_trans.
            Focus 2.
            apply valid_hi.
            unfold ivlo, addIntv.
            simpl in valid_sub_hi.
            repeat rewrite <- Rsub_eq_Ropp_Rplus in valid_sub_hi.
            repeat rewrite <- Q2R_minus in valid_sub_hi.
            rewrite <- Q2R_max4 in valid_sub_hi.
            unfold absIvUpd; auto. }
        { pose proof (interval_multiplication_valid (iv1 :=(Q2R (fst iv1),Q2R (snd iv1))) (iv2:=(Q2R (fst iv2), Q2R (snd iv2)))) as valid_mul.
          specialize (valid_mul v1 v2 valid_bounds_e1 valid_bounds_e2).
          unfold contained in valid_mul.
          unfold isSupersetIntv in valid_bin.
          apply andb_prop_elim in valid_bin; destruct valid_bin as [valid_lo valid_hi].
          apply Is_true_eq_true in valid_lo; apply Is_true_eq_true in valid_hi.
          apply Qle_bool_iff in valid_lo; apply Qle_bool_iff in valid_hi.
          apply Qle_Rle in valid_lo; apply Qle_Rle in valid_hi.
          destruct valid_mul as [valid_mul_lo valid_mul_hi].
          split.
          - eapply Rle_trans. apply valid_lo.
            unfold ivlo. unfold multIntv.
            simpl in valid_mul_lo.
            repeat rewrite <- Q2R_mult in valid_mul_lo.
            rewrite <- Q2R_min4 in valid_mul_lo.
            unfold absIvUpd; auto.
          - eapply Rle_trans.
            Focus 2.
            apply valid_hi.
            unfold ivlo, addIntv.
            simpl in valid_mul_hi.
            repeat rewrite <- Q2R_mult in valid_mul_hi.
            rewrite <- Q2R_max4 in valid_mul_hi.
            unfold absIvUpd; auto. }
        { pose proof (interval_division_valid (a:=v1) (b:=v2) (iv1:=(Q2R (fst iv1), Q2R (snd iv1))) (iv2:=(Q2R (fst iv2),Q2R (snd iv2)))) as valid_div.
          unfold contained in valid_div.
          unfold isSupersetIntv in valid_bin.
          apply andb_prop_elim in valid_bin; destruct valid_bin as [valid_bin nodiv0].
          apply andb_prop_elim in valid_bin; destruct valid_bin as [valid_lo valid_hi].
          apply Is_true_eq_true in valid_lo; apply Is_true_eq_true in valid_hi.
          apply Qle_bool_iff in valid_lo; apply Qle_bool_iff in valid_hi.
          apply Qle_Rle in valid_lo; apply Qle_Rle in valid_hi.
          apply orb_prop_elim in nodiv0.
          assert (snd iv2 < 0 \/ 0 < fst iv2).
          - destruct nodiv0 as [lt_0 | lt_0];
              apply andb_prop_elim in lt_0; destruct lt_0 as [le_0 neq_0];
                apply Is_true_eq_true in le_0; apply Is_true_eq_true in neq_0;
                  apply negb_true_iff in neq_0; apply Qeq_bool_neq in neq_0;
                    rewrite Qle_bool_iff in le_0;
                    rewrite Qle_lteq in le_0; destruct le_0 as [lt_0 | eq_0];
                      [ | exfalso; apply neq_0; auto | | exfalso; apply neq_0; symmetry; auto]; auto.
          - destruct valid_div as [valid_div_lo valid_div_hi]; simpl; try auto.
            + rewrite <- Q2R0_is_0.
              destruct H; [left | right]; apply Qlt_Rlt; auto.
            + unfold divideInterval, IVlo, IVhi in valid_div_lo, valid_div_hi.
              simpl in *.
              assert (Q2R (fst iv2) <= (Q2R (snd iv2)))%R by lra.
              assert (~ snd iv2 == 0).
              * destruct H; try lra.
                hnf; intros ivhi2_0.
                apply Rle_Qle in H0.
                rewrite ivhi2_0 in H0.
                lra.
              * assert (~ fst iv2 == 0).
                { destruct H; try lra.
                  hnf; intros ivlo2_0.
                  apply Rle_Qle in H0.
                  rewrite ivlo2_0 in H0.
                  lra. }
                { split.
                  - eapply Rle_trans. apply valid_lo.
                    unfold ivlo. unfold multIntv.
                    simpl in valid_div_lo.
                    rewrite <- Q2R_inv in valid_div_lo; [ | auto].
                    rewrite <- Q2R_inv in valid_div_lo; [ | auto].
                    repeat rewrite <- Q2R_mult in valid_div_lo.
                    rewrite <- Q2R_min4 in valid_div_lo; auto.
                  - eapply Rle_trans.
                    Focus 2.
                    apply valid_hi.
                    simpl in valid_div_hi.
                    rewrite <- Q2R_inv in valid_div_hi; [ | auto].
                    rewrite <- Q2R_inv in valid_div_hi; [ | auto].
                    repeat rewrite <- Q2R_mult in valid_div_hi.
                    rewrite <- Q2R_max4 in valid_div_hi; auto. } }
476
Qed.
477 478

Theorem validIntervalboundsCmd_sound (f:cmd Q) (absenv:analysisResult):
479 480 481 482
  forall E vR fVars dVars outVars elo ehi err P,
    ssaPrg f (NatSet.union fVars dVars) outVars ->
    bstep (toRCmd f) E 0%R vR  ->
    (forall v, NatSet.mem v dVars = true ->
483 484
          exists vR,
            E v = Some vR /\
485 486 487 488 489 490
            (Q2R (fst (fst (absenv (Var Q v)))) <= vR <= Q2R (snd (fst (absenv (Var Q v)))))%R) ->
    (forall v, NatSet.mem v fVars = true ->
          exists vR,
            E v = Some vR /\
            (Q2R (fst (P v)) <= vR <= Q2R (snd (P v)))%R) ->
    validIntervalboundsCmd f absenv P dVars = true ->
491
    absenv (getRetExp f) = ((elo, ehi), err) ->
Heiko Becker's avatar
Heiko Becker committed
492
    (Q2R elo <=  vR <= Q2R ehi)%R.
493 494
Proof.
  induction f;
495
    intros E envR fVars dVars outVars elo ehi err P ssa_f eval_f dVars_sound fVars_valid valid_bounds_f absenv_f.
496 497 498 499 500
  - inversion ssa_f; subst.
    inversion eval_f; subst.
    unfold validIntervalboundsCmd in valid_bounds_f.
    andb_to_prop valid_bounds_f.
    eapply IHf; eauto.
501
    admit.
502 503 504
    intros v0 mem_v0.
    unfold updEnv.
    case_eq (v0 =? n); intros v0_eq.
505
    + rename L into eq_lo;
506 507 508 509 510 511 512 513
        rename R1 into eq_hi.
      apply Qeq_bool_iff in eq_lo;
        apply Qeq_eqR in eq_lo.
      apply Qeq_bool_iff in eq_hi;
        apply Qeq_eqR in eq_hi.
      rewrite Nat.eqb_eq in v0_eq.
      subst.
      rewrite <- eq_lo, <- eq_hi.
514 515
      exists v.
      split; auto.
516 517 518
      eapply validIntervalbounds_sound; eauto.
      admit.
    + apply dVars_sound. rewrite NatSet.mem_spec.
519 520
      rewrite NatSet.mem_spec in mem_v0.
      rewrite NatSet.add_spec in mem_v0.
521 522 523 524
      destruct mem_v0; try auto.
      rewrite Nat.eqb_neq in v0_eq.
      exfalso; apply v0_eq; auto.
    + admit.
525 526 527
  - unfold validIntervalboundsCmd in valid_bounds_f.
    inversion eval_f; subst.
    unfold updEnv.
528 529 530 531 532
    assert (Q2R (fst (fst (absenv e))) <= envR <= Q2R (snd (fst (absenv e))))%R.
    + eapply validIntervalbounds_sound; eauto.
      admit.
    + simpl in *. rewrite absenv_f in *; auto.
Admitted.