1 / 206

Software Verification With Liquid Types

This work by Ranjit Jhala and collaborators from UC San Diego explores advanced techniques in software verification using liquid types. The paper discusses the formulation of algorithms, such as `min_index`, along with their formal specifications and invariants to ensure memory safety. It delves into critical aspects of verification, including type-checking, refinement types, and inductive reasoning. By leveraging liquid types, the authors provide a framework for verifying properties of collections, polymorphism, and data structures, making a significant contribution to the field.

tillie
Download Presentation

Software Verification With Liquid Types

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Software Verification With Liquid Types RanjitJhala, UC San Diego (with Pat Rondon, Ming Kawaguchi)

  2. Software Verification intmin_index(int [] a){ r = 0; n = a.length; for (i = 0; i < n; i++){ if (a[i] < a[r]) r = i; } return r; }

  3. Example: Memory Safety intmin_index(int [] a){ r = 0; n = a.length; for (i = 0; i < n; i++){ if (a[i] < a[r]) r = i; } return r; } • Access In Array Bounds ?

  4. Example: Memory Safety intmin_index(int [] a){ r = 0; n = a.length; for (i = 0; i < n; i++){ if (a[i] < a[r]) r = i; } return r; } assert (0<=r && r<n) • How to prove assert ?

  5. Example: Memory Safety intmin_index(int [] a){ r = 0; n = a.length; //@invariant: 0·iÆ0·rÆr<n for (i = 0; i < n; i++){ if (a[i] < a[r]) r = i; } return r; }

  6. Invariants intmin_index(int [] a){ r = 0; n = a.length; //@invariant: 0·iÆ0·rÆr<n for (i = 0; i < n; i++){ if (a[i] < a[r]) r = i; } return r; } • By Man [Floyd-Hoare] • Or Machine[Cousot-Cousot]

  7. But, what of … Closures Collections Polymorphism Data Structures …?

  8. But, what of … H-O Logics? Quantifiers? Induction?

  9. Automation

  10. H-O Logics? Quantifiers? Induction? A Solution: Types

  11. Part I • Types and Invariants • Part II • Closures, Collections, Generics • Part III • Induction for Data Structures

  12. Part I • Types and Invariants

  13. Part I • Refinement Types [Zenger ’97, Owre-Rushby-Shankar ’98, Xi-Pfenning ’98]

  14. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 min_index:a:intarray->int

  15. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 Refinement min_index:{a:intarray|0≺ a.len}->{v:int|0≼v≺a.len} Type

  16. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 “Requires” min_index:{a:intarray|0≺ a.len}->{v:int|0≼v≺a.len}

  17. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 “Ensures” min_index:{a:intarray|0≺ a.len}->{v:int|0≼v≺a.len}

  18. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 loop: {r:int|0≼ r≺ a.len}->{i:int|0≼i}->{v:int|0≼ v≺ a.len}

  19. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 loop: {r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len}

  20. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 loop: {r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} “Requires”

  21. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 loop: {r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} “Ensures”

  22. Part I • Refinement Types • 1. Type-checking • 2. Refine-checking • 3. Refine-Inference

  23. loop : r:int -> i:int -> int let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is int • loop : … • r : int • i: int ⊢ r “subtype-of” int

  24. loop : r:int -> i:int -> int let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is int • loop : … • r : int • i: int ⊢ r <: int

  25. loop : r:int -> i:int -> int let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 Assume Prove index is int • loop : … • r : int • i: int ⊢ i <: int

  26. loop : r:int -> i:int -> int let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 3 Assume Prove input is int • loop : … • i : int • r : int • r': int • i': int ⊢ r' <: int

  27. loop : r:int -> i:int -> int let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 3 4 Assume Prove output is int • loop : … • i : int • r : int • r': int • i': int ⊢ loopr'i'<: int

  28. loop : r:int -> i:int -> int let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 3 4 5 Assume Prove input is int • loop : … • i : int • r : int • r': int • i': int ⊢ 0 <: int

  29. Part I • Refinement Types • 1. Type-checking • 2. Refine-checking • 3. Refine-Inference

  30. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 min_index {a:0≺a.len}->{v:0≼v≺ a.len} loop {r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len}

  31. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 3 4 5 Assume Prove output is ensured • r :0≼ r≺ a.len • i :0≼ i • [i≽ a.len]

  32. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is ensured • r :0≼ r≺ a.len • i :0≼ i • [i≽ a.len] ⊢ {v=r}<:{0≼ v≺ a.len}

  33. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is ensured • r :0≼ r≺ a.len • i :0≼ i • [i≽ a.len] ⊢ {v=r}<:{0≼ v≺ a.len}

  34. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is ensured 0≼ r≺ a.len ⋀0≼ i ⋀i≽ a.len ⊢ {v=r}<:{0≼ v≺ a.len}

  35. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is ensured 0≼ r≺ a.len ⋀0≼ i ⋀i≽ a.len ⋀ {v=r}<:{0≼ v≺ a.len}

  36. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 Assume Prove output is ensured 0≼ r≺ a.len ⋀0≼ i ⋀i≽ a.len ⇒ ⋀ v=r0≼ v≺ a.len

  37. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 0≼ r≺ a.len ⋀0≼ i ⋀i≽ a.len Is Valid? Yes. ⇒ ⋀ v=r0≼ v≺ a.len

  38. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 4 3 5 Assume Prove index in bounds • r :0≼ r≺ a.len • i :0≼ i • [i≺ a.len] ⊢ {v=i}<:{0≼ v≺ a.len} • [i≺ a.len]

  39. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 2 0≼ r≺ a.len ⋀0≼ i ⋀i≺ a.len Is Valid? Yes. ⇒ ⋀ v=i0≼ v≺ a.len

  40. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 4 3 5 Prove input as required ⊢ {v=r'}<:{0≼ v≺ a.len}

  41. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 3 Assume Prove input as required • r :0≼ r≺ a.len • i :0≼ i • [i≺ a.len] • i':i'=i+1 ⊢ {v=r'}<:{0≼ v≺ a.len} r':r'=i∨r'=r

  42. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 3 • 0≼ r≺ a.len • ⋀ 0≼ i • ⋀i≺ a.len • ⋀ r'=i∨r'=r • ⋀ i'=i+1 Is Valid? Yes! ⇒ ⋀ v=r'0≼ v≺ a.len

  43. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 4 3 5 Prove output is ensured ⊢ {0≼ v≺a.len}<:{0≼ v≺a.len} Trivial.

  44. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 1 2 4 3 5 Assume Prove input as required ⊢ {v=0}<:{0≼ v≺a.len} • a :0≺ a.len

  45. loop:{r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len} let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 5 Is Valid? Indeed. ⇒ ⋀ v=0 0≼ v≺a.len • 0≺ a.len

  46. Part I • Refinement Types • 1. Type-checking • 2. Refine-checking • 3. Refine-Inference

  47. let min_indexa = let rec loopr i = if i>= a.lengththen r else let r' = a[i] < a[r] ? i : r let i' = i + 1 loopr' i' loop 0 0 min_index {a:0≺a.len}->{v:0≼v≺ a.len} loop {r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len}

  48. Writing Types is Hard Work! min_index {a:0≺a.len}->{v:0≼v≺ a.len} loop {r:0≼ r≺a.len}->{i:0≼i}->{v:0≼v≺ a.len}

  49. Automatic Refinement Inference • Writing Types is Hard Work! loop:???

  50. Automatic Refinement Inference • 1. Templates • 2. Constraints • 3. Fixpoint[MC/AI] loop:???

More Related