# Coq tutorial Program verification using Coq

Save this PDF as:

Size: px
Start display at page:

Download "Coq tutorial Program verification using Coq"

## Transcription

1 Coq tutorial Program verification using Coq CNRS Université Paris Sud TYPES summer school August 23th, 2005

2 Introduction This lecture: how to use Coq to verify purely functional programs Thursday s lecture: verification of imperative programs (using Coq and other provers)

3 Introduction This lecture: how to use Coq to verify purely functional programs Thursday s lecture: verification of imperative programs (using Coq and other provers)

4 The goal To get a purely functional (ML) program which is proved correct There are mostly two ways: 1. define your ML function in Coq and prove it correct 2. give the Coq function a richer type (= the specification) and get the ML function via program extraction

5 The goal To get a purely functional (ML) program which is proved correct There are mostly two ways: 1. define your ML function in Coq and prove it correct 2. give the Coq function a richer type (= the specification) and get the ML function via program extraction

6 The goal To get a purely functional (ML) program which is proved correct There are mostly two ways: 1. define your ML function in Coq and prove it correct 2. give the Coq function a richer type (= the specification) and get the ML function via program extraction

7 The goal To get a purely functional (ML) program which is proved correct There are mostly two ways: 1. define your ML function in Coq and prove it correct 2. give the Coq function a richer type (= the specification) and get the ML function via program extraction

8 Program extraction Two sorts: Prop : the sort of logic terms Set : the sort of informative terms Program extraction turns the informative contents of a Coq term into an ML program while removing the logical contents

9 Program extraction Two sorts: Prop : the sort of logic terms Set : the sort of informative terms Program extraction turns the informative contents of a Coq term into an ML program while removing the logical contents

10 Outline 1. Direct method (ML function defined in Coq) 2. Use of Coq dependent types 3. Modules and functors

11 Running example Finite sets library implemented with balanced binary search trees 1. useful 2. complex 3. purely functional The Ocaml library Set was verified using Coq One (balancing) bug was found (fixed in current release)

12 Running example Finite sets library implemented with balanced binary search trees 1. useful 2. complex 3. purely functional The Ocaml library Set was verified using Coq One (balancing) bug was found (fixed in current release)

13 Running example Finite sets library implemented with balanced binary search trees 1. useful 2. complex 3. purely functional The Ocaml library Set was verified using Coq One (balancing) bug was found (fixed in current release)

14 Direct method Most ML functions can be defined in Coq f : τ 1 τ 2 A specification is a relation S : τ 1 τ 2 Prop f verifies S if x : τ 1. (S x (f x)) The proof is conducted following the definition of f

15 Direct method Most ML functions can be defined in Coq f : τ 1 τ 2 A specification is a relation S : τ 1 τ 2 Prop f verifies S if x : τ 1. (S x (f x)) The proof is conducted following the definition of f

16 Direct method Most ML functions can be defined in Coq f : τ 1 τ 2 A specification is a relation S : τ 1 τ 2 Prop f verifies S if x : τ 1. (S x (f x)) The proof is conducted following the definition of f

17 Binary search trees The type of trees Inductive tree : Set := Empty Node : tree Z tree tree. The membership relation Inductive In (x:z) : tree Prop := In_left : l r y, In x l In x (Node l y r) In_right : l r y, In x r In x (Node l y r) Is_root : l r, In x (Node l x r).

18 Binary search trees The type of trees Inductive tree : Set := Empty Node : tree Z tree tree. The membership relation Inductive In (x:z) : tree Prop := In_left : l r y, In x l In x (Node l y r) In_right : l r y, In x r In x (Node l y r) Is_root : l r, In x (Node l x r).

19 The function is empty ML let is_empty = function Empty true false Coq Definition is_empty (s:tree) : bool := match s with Empty true false end. Correctness Theorem is_empty_correct : s, (is_empty s)=true ( x, (In x s)). Proof. destruct s; simpl; intuition....

20 The function is empty ML let is_empty = function Empty true false Coq Definition is_empty (s:tree) : bool := match s with Empty true false end. Correctness Theorem is_empty_correct : s, (is_empty s)=true ( x, (In x s)). Proof. destruct s; simpl; intuition....

21 The function is empty ML let is_empty = function Empty true false Coq Definition is_empty (s:tree) : bool := match s with Empty true false end. Correctness Theorem is_empty_correct : s, (is_empty s)=true ( x, (In x s)). Proof. destruct s; simpl; intuition....

22 The function is empty ML let is_empty = function Empty true false Coq Definition is_empty (s:tree) : bool := match s with Empty true false end. Correctness Theorem is_empty_correct : s, (is_empty s)=true ( x, (In x s)). Proof. destruct s; simpl; intuition....

23 The function mem ML let rec mem x = function Empty false Node (l, y, r) let c = compare x y in if c < 0 then mem x l else if c = 0 then true else mem x r

24 The function mem Coq Fixpoint mem (x:z) (s:tree) {struct s} : bool := match s with Empty false Node l y r match compare x y with Lt mem x l Eq true Gt mem x r end end. assuming Inductive order : Set := Lt Eq Gt. Hypothesis compare : Z Z order.

25 The function mem Coq Fixpoint mem (x:z) (s:tree) {struct s} : bool := match s with Empty false Node l y r match compare x y with Lt mem x l Eq true Gt mem x r end end. assuming Inductive order : Set := Lt Eq Gt. Hypothesis compare : Z Z order.

26 Correctness of the function mem to be a binary search tree Inductive bst : tree Prop := bst_empty : bst Empty bst_node : x l r, bst l bst r ( y, In y l y < x) ( y, In y r x < y) bst (Node l x r). Theorem mem_correct : x s, bst s ((mem x s)=true In x s). specification S has the shape P x Q x (f x)

27 Correctness of the function mem to be a binary search tree Inductive bst : tree Prop := bst_empty : bst Empty bst_node : x l r, bst l bst r ( y, In y l y < x) ( y, In y r x < y) bst (Node l x r). Theorem mem_correct : x s, bst s ((mem x s)=true In x s). specification S has the shape P x Q x (f x)

28 Correctness of the function mem to be a binary search tree Inductive bst : tree Prop := bst_empty : bst Empty bst_node : x l r, bst l bst r ( y, In y l y < x) ( y, In y r x < y) bst (Node l x r). Theorem mem_correct : x s, bst s ((mem x s)=true In x s). specification S has the shape P x Q x (f x)

29 Modularity To prove mem correct requires a property for compare Hypothesis compare_spec : x y, match compare x y with Lt x < y Eq x = y Gt x > y end. Theorem mem_correct : x s, bst s ((mem x s)=true In x s). Proof. induction s; simpl.... generalize (compare_spec x y); destruct (compare x y)....

30 Modularity To prove mem correct requires a property for compare Hypothesis compare_spec : x y, match compare x y with Lt x < y Eq x = y Gt x > y end. Theorem mem_correct : x s, bst s ((mem x s)=true In x s). Proof. induction s; simpl.... generalize (compare_spec x y); destruct (compare x y)....

31 Modularity To prove mem correct requires a property for compare Hypothesis compare_spec : x y, match compare x y with Lt x < y Eq x = y Gt x > y end. Theorem mem_correct : x s, bst s ((mem x s)=true In x s). Proof. induction s; simpl.... generalize (compare_spec x y); destruct (compare x y)....

32 Partial functions If the function f is partial, it has the Coq type f : x : τ 1. (P x) τ 2 Example: min elt returning the smallest element of a tree min elt : s : tree. s = Empty Z specification s. h : s = Empty. bst s In (min elt s h) s x. In x s min elt s h x

33 Partial functions If the function f is partial, it has the Coq type f : x : τ 1. (P x) τ 2 Example: min elt returning the smallest element of a tree min elt : s : tree. s = Empty Z specification s. h : s = Empty. bst s In (min elt s h) s x. In x s min elt s h x

34 Partial functions If the function f is partial, it has the Coq type f : x : τ 1. (P x) τ 2 Example: min elt returning the smallest element of a tree min elt : s : tree. s = Empty Z specification s. h : s = Empty. bst s In (min elt s h) s x. In x s min elt s h x

35 Partial functions If the function f is partial, it has the Coq type f : x : τ 1. (P x) τ 2 Example: min elt returning the smallest element of a tree min elt : s : tree. s = Empty Z specification s. h : s = Empty. bst s In (min elt s h) s x. In x s min elt s h x

36 Even the definition of a partial function is not easy ML let rec min_elt = function Empty assert false Node (Empty, x, ) x Node (l,, ) min_elt l Coq 1. assert false elimination on a proof of False 2. recursive call requires a proof that l is not empty

37 Even the definition of a partial function is not easy ML let rec min_elt = function Empty assert false Node (Empty, x, ) x Node (l,, ) min_elt l Coq 1. assert false elimination on a proof of False 2. recursive call requires a proof that l is not empty

38 Even the definition of a partial function is not easy ML let rec min_elt = function Empty assert false Node (Empty, x, ) x Node (l,, ) min_elt l Coq 1. assert false elimination on a proof of False 2. recursive call requires a proof that l is not empty

39 min elt: a solution Fixpoint min_elt (s:tree) (h: s=empty) { struct s } : Z := match s return s=empty Z with Empty (fun (h: Empty=Empty) False_rec (h (refl_equal Empty))) Node l x (fun h match l as a return a=l Z with Empty (fun x) (fun h min_elt l (Node_not_empty h)) end (refl_equal l)) end h.

40 min elt: a solution Fixpoint min_elt (s:tree) (h: s=empty) { struct s } : Z := match s return s=empty Z with Empty (fun (h: Empty=Empty) False_rec (h (refl_equal Empty))) Node l x (fun h match l as a return a=l Z with Empty (fun x) (fun h min_elt l (Node_not_empty h)) end (refl_equal l)) end h.

41 Definition by proof Idea: use the proof editor to build the whole definition Definition min_elt : s, s=empty Z. Proof. induction s; intro h. elim h; auto. destruct s1. exact z. apply IHs1; discriminate. Defined. But did we define the right function?

42 Definition by proof Idea: use the proof editor to build the whole definition Definition min_elt : s, s=empty Z. Proof. induction s; intro h. elim h; auto. destruct s1. exact z. apply IHs1; discriminate. Defined. But did we define the right function?

43 Definition by proof Idea: use the proof editor to build the whole definition Definition min_elt : s, s=empty Z. Proof. induction s; intro h. elim h; auto. destruct s1. exact z. apply IHs1; discriminate. Defined. But did we define the right function?

44 Definition by proof Idea: use the proof editor to build the whole definition Definition min_elt : s, s=empty Z. Proof. induction s; intro h. elim h; auto. destruct s1. exact z. apply IHs1; discriminate. Defined. But did we define the right function?

45 Definition by proof (cont d) We can check the extracted code: Extraction min_elt. (** val min_elt : tree z **) let rec min_elt = function Empty assert false (* absurd case *) Node (t0, z0, t1) (match t0 with Empty z0 Node (s1_1, z1, s1_2) min_elt t0)

46 The refine tactic Definition min_elt : s, s=empty Z. Proof. refine (fix min (s:tree) (h: s=empty) { struct s } : Z := match s return s=empty Z with Empty (fun h _) Node l x (fun h match l as a return a=l Z with Empty (fun x) (fun h min l _) end _) end h)....

47 The refine tactic Definition min_elt : s, s=empty Z. Proof. refine (fix min (s:tree) (h: s=empty) { struct s } : Z := match s return s=empty Z with Empty (fun h _) Node l x (fun h match l as a return a=l Z with Empty (fun x) (fun h min l _) end _) end h)....

48 A last solution To make the function total Fixpoint min_elt (s:tree) : Z := match s with Empty 0 Node Empty z z Node l min_elt l end. Correctness theorem almost unchanged: Theorem min_elt_correct : s, s=empty bst s In (min_elt s) s x, In x s min_elt s <= x.

49 A last solution To make the function total Fixpoint min_elt (s:tree) : Z := match s with Empty 0 Node Empty z z Node l min_elt l end. Correctness theorem almost unchanged: Theorem min_elt_correct : s, s=empty bst s In (min_elt s) s x, In x s min_elt s <= x.

50 A last solution To make the function total Fixpoint min_elt (s:tree) : Z := match s with Empty 0 Node Empty z z Node l min_elt l end. Correctness theorem almost unchanged: Theorem min_elt_correct : s, s=empty bst s In (min_elt s) s x, In x s min_elt s <= x.

51 Functions that are not structurally recursive One solution is to use a well-founded induction principle such as well_founded_induction : (A : Set) (R : A A Prop), well_founded R P : A Set, ( x : A, ( y : A, R y x P y) P x) a : A, P a Defining the function requires to build proof terms (of R y x) similar to partial functions similar solutions

52 Functions that are not structurally recursive One solution is to use a well-founded induction principle such as well_founded_induction : (A : Set) (R : A A Prop), well_founded R P : A Set, ( x : A, ( y : A, R y x P y) P x) a : A, P a Defining the function requires to build proof terms (of R y x) similar to partial functions similar solutions

53 Example: the subset function let rec subset s1 s2 = match (s1, s2) with Empty, true, Empty false Node (l1, v1, r1), Node (l2, v2, r2) let c = compare v1 v2 in if c = 0 then subset l1 l2 && subset r1 r2 else if c < 0 then subset (Node (l1, v1, Empty)) l2 && subset r1 s2 else subset (Node (Empty, v1, r1)) r2 && subset l1 s2

54 Example: the subset function let rec subset s1 s2 = match (s1, s2) with Empty, true, Empty false Node (l1, v1, r1), Node (l2, v2, r2) let c = compare v1 v2 in if c = 0 then subset l1 l2 && subset r1 r2 else if c < 0 then subset (Node (l1, v1, Empty)) l2 && subset r1 s2 else subset (Node (Empty, v1, r1)) r2 && subset l1 s2

55 Induction over two trees Fixpoint cardinal_tree (s:tree) : nat := match s with Empty O Node l r (S (plus (cardinal_tree l) (cardinal_tree r))) end. Lemma cardinal_rec2 : (P:tree tree Set), ( (x x :tree), ( (y y :tree), (lt (plus (cardinal_tree y) (cardinal_tree y )) (plus (cardinal_tree x) (cardinal_tree x ))) (P x x )) (x x :tree), (P x x ).

56 Induction over two trees Fixpoint cardinal_tree (s:tree) : nat := match s with Empty O Node l r (S (plus (cardinal_tree l) (cardinal_tree r))) end. Lemma cardinal_rec2 : (P:tree tree Set), ( (x x :tree), ( (y y :tree), (lt (plus (cardinal_tree y) (cardinal_tree y )) (plus (cardinal_tree x) (cardinal_tree x ))) (P x x )) (x x :tree), (P x x ).

57 Defining the subset function Definition subset : tree tree bool. Proof. intros s1 s2; pattern s1, s2; apply cardinal_rec2. destruct x.... destruct x.... intros; case (compare z z0). (* z < z0 *) refine (andb (H (Node x1 z Empty) x 2 ) (H x2 (Node x 1 z0 x 2) )); simpl; omega. (* z = z0 *) refine (andb (H x1 x 1 ) (H x2 x 2 )); simpl ; omega. (* z > z0 *) refine (andb (H (Node Empty z x2) x 2 ) (H x1 (Node x 1 z0 x 2) )); simpl ; omega. Defined.

58 Defining the subset function Definition subset : tree tree bool. Proof. intros s1 s2; pattern s1, s2; apply cardinal_rec2. destruct x.... destruct x.... intros; case (compare z z0). (* z < z0 *) refine (andb (H (Node x1 z Empty) x 2 ) (H x2 (Node x 1 z0 x 2) )); simpl; omega. (* z = z0 *) refine (andb (H x1 x 1 ) (H x2 x 2 )); simpl ; omega. (* z > z0 *) refine (andb (H (Node Empty z x2) x 2 ) (H x1 (Node x 1 z0 x 2) )); simpl ; omega. Defined.

59 Defining the subset function Definition subset : tree tree bool. Proof. intros s1 s2; pattern s1, s2; apply cardinal_rec2. destruct x.... destruct x.... intros; case (compare z z0). (* z < z0 *) refine (andb (H (Node x1 z Empty) x 2 ) (H x2 (Node x 1 z0 x 2) )); simpl; omega. (* z = z0 *) refine (andb (H x1 x 1 ) (H x2 x 2 )); simpl ; omega. (* z > z0 *) refine (andb (H (Node Empty z x2) x 2 ) (H x1 (Node x 1 z0 x 2) )); simpl ; omega. Defined.

60 Defining the subset function Definition subset : tree tree bool. Proof. intros s1 s2; pattern s1, s2; apply cardinal_rec2. destruct x.... destruct x.... intros; case (compare z z0). (* z < z0 *) refine (andb (H (Node x1 z Empty) x 2 ) (H x2 (Node x 1 z0 x 2) )); simpl; omega. (* z = z0 *) refine (andb (H x1 x 1 ) (H x2 x 2 )); simpl ; omega. (* z > z0 *) refine (andb (H (Node Empty z x2) x 2 ) (H x1 (Node x 1 z0 x 2) )); simpl ; omega. Defined.

61 Defining the subset function Definition subset : tree tree bool. Proof. intros s1 s2; pattern s1, s2; apply cardinal_rec2. destruct x.... destruct x.... intros; case (compare z z0). (* z < z0 *) refine (andb (H (Node x1 z Empty) x 2 ) (H x2 (Node x 1 z0 x 2) )); simpl; omega. (* z = z0 *) refine (andb (H x1 x 1 ) (H x2 x 2 )); simpl ; omega. (* z > z0 *) refine (andb (H (Node Empty z x2) x 2 ) (H x1 (Node x 1 z0 x 2) )); simpl ; omega. Defined.

62 Defining the subset function Definition subset : tree tree bool. Proof. intros s1 s2; pattern s1, s2; apply cardinal_rec2. destruct x.... destruct x.... intros; case (compare z z0). (* z < z0 *) refine (andb (H (Node x1 z Empty) x 2 ) (H x2 (Node x 1 z0 x 2) )); simpl; omega. (* z = z0 *) refine (andb (H x1 x 1 ) (H x2 x 2 )); simpl ; omega. (* z > z0 *) refine (andb (H (Node Empty z x2) x 2 ) (H x1 (Node x 1 z0 x 2) )); simpl ; omega. Defined.

63 Extraction Extraction well_founded_induction. let rec well_founded_induction x a = x a (fun y well_founded_induction x y) Extraction Inline cardinal_rec2... Extraction subset. gives the expected ML code

64 Extraction Extraction well_founded_induction. let rec well_founded_induction x a = x a (fun y well_founded_induction x y) Extraction Inline cardinal_rec2... Extraction subset. gives the expected ML code

65 To sum up, defining an ML function in Coq and prove it correct seems the obvious way, but it can be rather complex when the function is partial, and/or is not structurally recursive

66 Use of dependent types Instead of 1. defining a pure function, and 2. proving its correctness let us do both at the same time We can give Coq functions richer types that are specifications Example f : {n : Z n 0} {p : Z prime p}

67 Use of dependent types Instead of 1. defining a pure function, and 2. proving its correctness let us do both at the same time We can give Coq functions richer types that are specifications Example f : {n : Z n 0} {p : Z prime p}

68 Use of dependent types Instead of 1. defining a pure function, and 2. proving its correctness let us do both at the same time We can give Coq functions richer types that are specifications Example f : {n : Z n 0} {p : Z prime p}

69 The type {x : A P} Notation for sig A (fun x P) where Inductive sig (A : Set) (P : A Prop) : Set := exist : x:a, P x sig P In practice, we adopt the more general specification f : x : τ 1, P x {y : τ 2 Q x y}

70 The type {x : A P} Notation for sig A (fun x P) where Inductive sig (A : Set) (P : A Prop) : Set := exist : x:a, P x sig P In practice, we adopt the more general specification f : x : τ 1, P x {y : τ 2 Q x y}

71 The type {x : A P} Notation for sig A (fun x P) where Inductive sig (A : Set) (P : A Prop) : Set := exist : x:a, P x sig P In practice, we adopt the more general specification f : x : τ 1, P x {y : τ 2 Q x y}

72 Example: the min elt function Definition min_elt : s, s=empty bst s { m:z In m s x, In x s m <= x }. We usually adopt a definition-by-proof (which is now a definition-and-proof) Still the same ML program Coq < Extraction sig. type a sig = a (* singleton inductive, whose constructor was exist *)

73 Example: the min elt function Definition min_elt : s, s=empty bst s { m:z In m s x, In x s m <= x }. We usually adopt a definition-by-proof (which is now a definition-and-proof) Still the same ML program Coq < Extraction sig. type a sig = a (* singleton inductive, whose constructor was exist *)

74 Example: the min elt function Definition min_elt : s, s=empty bst s { m:z In m s x, In x s m <= x }. We usually adopt a definition-by-proof (which is now a definition-and-proof) Still the same ML program Coq < Extraction sig. type a sig = a (* singleton inductive, whose constructor was exist *)

75 Specification of a boolean function: {A}+{B} Notation for sumbool A B where Inductive sumbool (A : Prop) (B : Prop) : Set := left : A sumbool A B right : B sumbool A B this is an informative disjunction Example: Definition is_empty : s, { s=empty } + { s=empty }. Extraction is a boolean Coq < Extraction sumbool. type sumbool = Left Right

76 Specification of a boolean function: {A}+{B} Notation for sumbool A B where Inductive sumbool (A : Prop) (B : Prop) : Set := left : A sumbool A B right : B sumbool A B this is an informative disjunction Example: Definition is_empty : s, { s=empty } + { s=empty }. Extraction is a boolean Coq < Extraction sumbool. type sumbool = Left Right

77 Specification of a boolean function: {A}+{B} Notation for sumbool A B where Inductive sumbool (A : Prop) (B : Prop) : Set := left : A sumbool A B right : B sumbool A B this is an informative disjunction Example: Definition is_empty : s, { s=empty } + { s=empty }. Extraction is a boolean Coq < Extraction sumbool. type sumbool = Left Right

78 Specification of a boolean function: {A}+{B} Notation for sumbool A B where Inductive sumbool (A : Prop) (B : Prop) : Set := left : A sumbool A B right : B sumbool A B this is an informative disjunction Example: Definition is_empty : s, { s=empty } + { s=empty }. Extraction is a boolean Coq < Extraction sumbool. type sumbool = Left Right

79 Variant sumor A+{B} Inductive sumor (A : Set) (B : Prop) : Set := inleft : A A + {B} inright : B A + {B} Extracts to an option type Example: Definition min_elt : s, bst s { m:z In m s x, In x s m <= x } + { s=empty }.

80 Variant sumor A+{B} Inductive sumor (A : Set) (B : Prop) : Set := inleft : A A + {B} inright : B A + {B} Extracts to an option type Example: Definition min_elt : s, bst s { m:z In m s x, In x s m <= x } + { s=empty }.

81 Variant sumor A+{B} Inductive sumor (A : Set) (B : Prop) : Set := inleft : A A + {B} inright : B A + {B} Extracts to an option type Example: Definition min_elt : s, bst s { m:z In m s x, In x s m <= x } + { s=empty }.

82 The mem function Hypothesis compare : x y, {x<y} + {x=y} + {x>y}. Definition mem : x s, bst s { In x s }+{ (In x s) }. Proof. induction s; intros. (* s = Empty *) right; intro h; inversion_clear h. (* s = Node s1 z s2 *) destruct (compare x z) as [[h1 h2] h3].... Defined.

83 The mem function Hypothesis compare : x y, {x<y} + {x=y} + {x>y}. Definition mem : x s, bst s { In x s }+{ (In x s) }. Proof. induction s; intros. (* s = Empty *) right; intro h; inversion_clear h. (* s = Node s1 z s2 *) destruct (compare x z) as [[h1 h2] h3].... Defined.

84 The mem function Hypothesis compare : x y, {x<y} + {x=y} + {x>y}. Definition mem : x s, bst s { In x s }+{ (In x s) }. Proof. induction s; intros. (* s = Empty *) right; intro h; inversion_clear h. (* s = Node s1 z s2 *) destruct (compare x z) as [[h1 h2] h3].... Defined.

85 The mem function Hypothesis compare : x y, {x<y} + {x=y} + {x>y}. Definition mem : x s, bst s { In x s }+{ (In x s) }. Proof. induction s; intros. (* s = Empty *) right; intro h; inversion_clear h. (* s = Node s1 z s2 *) destruct (compare x z) as [[h1 h2] h3].... Defined.

86 The mem function Hypothesis compare : x y, {x<y} + {x=y} + {x>y}. Definition mem : x s, bst s { In x s }+{ (In x s) }. Proof. induction s; intros. (* s = Empty *) right; intro h; inversion_clear h. (* s = Node s1 z s2 *) destruct (compare x z) as [[h1 h2] h3].... Defined.

87 To sum up, using dependent types we replace a definition and a proof by a single proof the ML function is still available using extraction On the contrary, it is more difficult to prove several properties of the same function

88 To sum up, using dependent types we replace a definition and a proof by a single proof the ML function is still available using extraction On the contrary, it is more difficult to prove several properties of the same function

89 Modules and functors Coq has a module system similar to Objective Caml s one Coq modules can contain definitions but also proofs, notations, hints for the auto tactic, etc. As Ocaml, Coq has functors i.e. functions from modules to modules

90 Modules and functors Coq has a module system similar to Objective Caml s one Coq modules can contain definitions but also proofs, notations, hints for the auto tactic, etc. As Ocaml, Coq has functors i.e. functions from modules to modules

91 Modules and functors Coq has a module system similar to Objective Caml s one Coq modules can contain definitions but also proofs, notations, hints for the auto tactic, etc. As Ocaml, Coq has functors i.e. functions from modules to modules

92 ML modules module type OrderedType = sig type t val compare: t t int end module Make(Ord: OrderedType) : sig type t val empty : t val mem : Ord.t t bool... end

93 Coq modules Module Type OrderedType. Parameter t : Set. Parameter eq : t t Prop. Parameter lt : t t Prop. Parameter compare : x y, {lt x y}+{eq x y}+{lt y x}. Axiom eq_refl : x, eq x x. Axiom eq_sym : x y, eq x y eq y x. Axiom eq_trans : x y z, eq x y eq y z eq x z. Axiom lt_trans : x y z, lt x y lt y z lt x z. Axiom lt_not_eq : x y, lt x y (eq x y). Hint Immediate eq_sym. Hint Resolve eq_refl eq_trans lt_not_eq lt_trans. End OrderedType.

94 Coq modules Module Type OrderedType. Parameter t : Set. Parameter eq : t t Prop. Parameter lt : t t Prop. Parameter compare : x y, {lt x y}+{eq x y}+{lt y x}. Axiom eq_refl : x, eq x x. Axiom eq_sym : x y, eq x y eq y x. Axiom eq_trans : x y z, eq x y eq y z eq x z. Axiom lt_trans : x y z, lt x y lt y z lt x z. Axiom lt_not_eq : x y, lt x y (eq x y). Hint Immediate eq_sym. Hint Resolve eq_refl eq_trans lt_not_eq lt_trans. End OrderedType.

95 Coq modules Module Type OrderedType. Parameter t : Set. Parameter eq : t t Prop. Parameter lt : t t Prop. Parameter compare : x y, {lt x y}+{eq x y}+{lt y x}. Axiom eq_refl : x, eq x x. Axiom eq_sym : x y, eq x y eq y x. Axiom eq_trans : x y z, eq x y eq y z eq x z. Axiom lt_trans : x y z, lt x y lt y z lt x z. Axiom lt_not_eq : x y, lt x y (eq x y). Hint Immediate eq_sym. Hint Resolve eq_refl eq_trans lt_not_eq lt_trans. End OrderedType.

96 Coq modules Module Type OrderedType. Parameter t : Set. Parameter eq : t t Prop. Parameter lt : t t Prop. Parameter compare : x y, {lt x y}+{eq x y}+{lt y x}. Axiom eq_refl : x, eq x x. Axiom eq_sym : x y, eq x y eq y x. Axiom eq_trans : x y z, eq x y eq y z eq x z. Axiom lt_trans : x y z, lt x y lt y z lt x z. Axiom lt_not_eq : x y, lt x y (eq x y). Hint Immediate eq_sym. Hint Resolve eq_refl eq_trans lt_not_eq lt_trans. End OrderedType.

97 The Coq functor for binary search trees Module BST (X: OrderedType). Inductive tree : Set := Empty Node : tree X.t tree tree. Fixpoint mem (x:x.t) (s:tree) {struct s} : bool :=... Inductive In (x:x.t) : tree Prop :=... Hint Constructors In. Inductive bst : tree Prop := bst_empty : bst Empty bst_node : x l r, bst l bst r ( y, In y l X.lt y x)...

98 Conclusion Coq is a tool of choice for the verification of purely functional programs, up to modules ML or Haskell code can be obtained via program extraction

99 Conclusion Coq is a tool of choice for the verification of purely functional programs, up to modules ML or Haskell code can be obtained via program extraction

### Regression Verification: Status Report

Regression Verification: Status Report Presentation by Dennis Felsing within the Projektgruppe Formale Methoden der Softwareentwicklung 2013-12-11 1/22 Introduction How to prevent regressions in software

### Practical Generic Programming with OCaml

Practical Generic Programming with OCaml Jeremy Yallop LFCS, University of Edinburgh ML Workshop 2007 Instead of this... type α tree = Node of α Branch of (α tree) (α tree) val show_tree : (α string) (α

### A Tutorial on [Co-]Inductive Types in Coq

A Tutorial on [Co-]Inductive Types in Coq Eduardo Giménez, Pierre Castéran May 1998 August 17, 2007 Abstract This document 1 is an introduction to the definition and use of inductive and co-inductive types

### GROUPS SUBGROUPS. Definition 1: An operation on a set G is a function : G G G.

Definition 1: GROUPS An operation on a set G is a function : G G G. Definition 2: A group is a set G which is equipped with an operation and a special element e G, called the identity, such that (i) the

### Adding GADTs to OCaml the direct approach

Adding GADTs to OCaml the direct approach Jacques Garrigue & Jacques Le Normand Nagoya University / LexiFi (Paris) https://sites.google.com/site/ocamlgadt/ Garrigue & Le Normand Adding GADTs to OCaml 1

### Automated Theorem Proving - summary of lecture 1

Automated Theorem Proving - summary of lecture 1 1 Introduction Automated Theorem Proving (ATP) deals with the development of computer programs that show that some statement is a logical consequence of

### Extraction of certified programs with effects from proofs with monadic types in Coq

Extraction of certified programs with effects from proofs with monadic types in Coq Marino Miculan 1 and Marco Paviotti 2 1 Dept. of Mathematics and Computer Science, University of Udine, Italy 2 IT University

### A binary search tree or BST is a binary tree that is either empty or in which the data element of each node has a key, and:

Binary Search Trees 1 The general binary tree shown in the previous chapter is not terribly useful in practice. The chief use of binary trees is for providing rapid access to data (indexing, if you will)

### MATHEMATICAL INDUCTION. Mathematical Induction. This is a powerful method to prove properties of positive integers.

MATHEMATICAL INDUCTION MIGUEL A LERMA (Last updated: February 8, 003) Mathematical Induction This is a powerful method to prove properties of positive integers Principle of Mathematical Induction Let P

### Lecture Notes on Linear Search

Lecture Notes on Linear Search 15-122: Principles of Imperative Computation Frank Pfenning Lecture 5 January 29, 2013 1 Introduction One of the fundamental and recurring problems in computer science is

### 3. Mathematical Induction

3. MATHEMATICAL INDUCTION 83 3. Mathematical Induction 3.1. First Principle of Mathematical Induction. Let P (n) be a predicate with domain of discourse (over) the natural numbers N = {0, 1,,...}. If (1)

### This asserts two sets are equal iff they have the same elements, that is, a set is determined by its elements.

3. Axioms of Set theory Before presenting the axioms of set theory, we first make a few basic comments about the relevant first order logic. We will give a somewhat more detailed discussion later, but

### ML for the Working Programmer

ML for the Working Programmer 2nd edition Lawrence C. Paulson University of Cambridge CAMBRIDGE UNIVERSITY PRESS CONTENTS Preface to the Second Edition Preface xiii xv 1 Standard ML 1 Functional Programming

### From Program Verification to Certified Binaries

From Program Verification to Certified Binaries The Quest for the Holy Grail of Software Engineering Angelos Manousaridis, Michalis A. Papakyriakou, and Nikolaos S. Papaspyrou National Technical University

### MATH 22. THE FUNDAMENTAL THEOREM of ARITHMETIC. Lecture R: 10/30/2003

MATH 22 Lecture R: 10/30/2003 THE FUNDAMENTAL THEOREM of ARITHMETIC You must remember this, A kiss is still a kiss, A sigh is just a sigh; The fundamental things apply, As time goes by. Herman Hupfeld

### Automated Proof Checking in Introductory Discrete Mathematics Classes. Andrew J. Haven

Automated Proof Checking in Introductory Discrete Mathematics Classes by Andrew J. Haven S.B. Mathematics and Computer Science and Engineering Massachusetts Institute of Technology, 2012 Submitted to the

### PROGRAM-ing Finger Trees in COQ

PROGRAM-ing Finger Trees in COQ Matthieu Sozeau Univ. Paris Sud, CNRS, Laboratoire LRI, UMR 8623, Orsay, F-91405 INRIA Futurs, ProVal, Parc Orsay Université, F-91893 sozeau@lri.fr Abstract Finger Trees

### Elementary Number Theory and Methods of Proof. CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.

Elementary Number Theory and Methods of Proof CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.edu/~cse215 1 Number theory Properties: 2 Properties of integers (whole

### APPLICATIONS OF THE ORDER FUNCTION

APPLICATIONS OF THE ORDER FUNCTION LECTURE NOTES: MATH 432, CSUSM, SPRING 2009. PROF. WAYNE AITKEN In this lecture we will explore several applications of order functions including formulas for GCDs and

### Programs, Proofs, and Service Networks

Programs, Proofs, and Service Networks Ruchira Datta Web Over Wireless Group University of California Berkeley, California January 30, 2002 1 Guiding Analogy Type checker for functional programming language

### Types, Polymorphism, and Type Reconstruction

Types, Polymorphism, and Type Reconstruction Sources This material is based on the following sources: Pierce, B.C., Types and Programming Languages. MIT Press, 2002. Kanellakis, P.C., Mairson, H.G. and

### OPERATIONAL TYPE THEORY by Adam Petcher Prepared under the direction of Professor Aaron Stump A thesis presented to the School of Engineering of

WASHINGTON NIVERSITY SCHOOL OF ENGINEERING AND APPLIED SCIENCE DEPARTMENT OF COMPTER SCIENCE AND ENGINEERING DECIDING JOINABILITY MODLO GROND EQATIONS IN OPERATIONAL TYPE THEORY by Adam Petcher Prepared

### Modular Development of Certified Program Verifiers with a Proof Assistant

Modular Development of Certified Program Verifiers with a Proof Assistant Adam Chlipala University of California, Berkeley, Computer Science Division adamc@cs.berkeley.edu Abstract I report on an experience

### Section IV.1: Recursive Algorithms and Recursion Trees

Section IV.1: Recursive Algorithms and Recursion Trees Definition IV.1.1: A recursive algorithm is an algorithm that solves a problem by (1) reducing it to an instance of the same problem with smaller

### Full and Complete Binary Trees

Full and Complete Binary Trees Binary Tree Theorems 1 Here are two important types of binary trees. Note that the definitions, while similar, are logically independent. Definition: a binary tree T is full

### 8 Divisibility and prime numbers

8 Divisibility and prime numbers 8.1 Divisibility In this short section we extend the concept of a multiple from the natural numbers to the integers. We also summarize several other terms that express

### So let us begin our quest to find the holy grail of real analysis.

1 Section 5.2 The Complete Ordered Field: Purpose of Section We present an axiomatic description of the real numbers as a complete ordered field. The axioms which describe the arithmetic of the real numbers

### Analysis of Algorithms I: Optimal Binary Search Trees

Analysis of Algorithms I: Optimal Binary Search Trees Xi Chen Columbia University Given a set of n keys K = {k 1,..., k n } in sorted order: k 1 < k 2 < < k n we wish to build an optimal binary search

### Binary Search Trees (BST)

Binary Search Trees (BST) 1. Hierarchical data structure with a single reference to node 2. Each node has at most two child nodes (a left and a right child) 3. Nodes are organized by the Binary Search

### Page 331, 38.4 Suppose a is a positive integer and p is a prime. Prove that p a if and only if the prime factorization of a contains p.

Page 331, 38.2 Assignment #11 Solutions Factor the following positive integers into primes. a. 25 = 5 2. b. 4200 = 2 3 3 5 2 7. c. 10 10 = 2 10 5 10. d. 19 = 19. e. 1 = 1. Page 331, 38.4 Suppose a is a

### Binary Multiplication

Binary Multiplication Q: How do we multiply two numbers? eg. 12, 345 6, 789 111105 987600 8641500 + 74070000 83, 810, 205 10111 10101 10111 00000 1011100 0000000 + 101110000 111100011 Pad, multiply and

### Output: 12 18 30 72 90 87. struct treenode{ int data; struct treenode *left, *right; } struct treenode *tree_ptr;

50 20 70 10 30 69 90 14 35 68 85 98 16 22 60 34 (c) Execute the algorithm shown below using the tree shown above. Show the exact output produced by the algorithm. Assume that the initial call is: prob3(root)

### 4.1. Definitions. A set may be viewed as any well defined collection of objects, called elements or members of the set.

Section 4. Set Theory 4.1. Definitions A set may be viewed as any well defined collection of objects, called elements or members of the set. Sets are usually denoted with upper case letters, A, B, X, Y,

### Functional Programming. Functional Programming Languages. Chapter 14. Introduction

Functional Programming Languages Chapter 14 Introduction Functional programming paradigm History Features and concepts Examples: Lisp ML 1 2 Functional Programming Functional Programming Languages The

### Lecture 12: Abstract data types

Lecture 12: Abstract data types Algebras Abstract data types Encapsulation and information hiding Parameterization Algebras Definition Which kinds of data do we want to discuss? What can we do with it?

### Interactive Software Verification

Interactive Software Verification Spring Term 2013 Holger Gast gasth@in.tum.de 25.6.2013 1 H.Gast gasth@in.tum.de Interactive Software Verification, 25.6.2013 Today Manipulating lists on the heap Ghost

### Mathematical Induction

Mathematical Induction In logic, we often want to prove that every member of an infinite set has some feature. E.g., we would like to show: N 1 : is a number 1 : has the feature Φ ( x)(n 1 x! 1 x) How

### Termination Checking: Comparing Structural Recursion and Sized Types by Examples

Termination Checking: Comparing Structural Recursion and Sized Types by Examples David Thibodeau Decemer 3, 2011 Abstract Termination is an important property for programs and is necessary for formal proofs

### CONTENTS 1. Peter Kahn. Spring 2007

CONTENTS 1 MATH 304: CONSTRUCTING THE REAL NUMBERS Peter Kahn Spring 2007 Contents 2 The Integers 1 2.1 The basic construction.......................... 1 2.2 Adding integers..............................

### Discrete Optimization

Discrete Optimization [Chen, Batson, Dang: Applied integer Programming] Chapter 3 and 4.1-4.3 by Johan Högdahl and Victoria Svedberg Seminar 2, 2015-03-31 Todays presentation Chapter 3 Transforms using

### Verifying Specifications with Proof Scores in CafeOBJ

Verifying Specifications with Proof Scores in CafeOBJ FUTATSUGI, Kokichi 二 木 厚 吉 Chair of Language Design Graduate School of Information Science Japan Advanced Institute of Science and Technology (JAIST)

### Introduction to Proofs

Chapter 1 Introduction to Proofs 1.1 Preview of Proof This section previews many of the key ideas of proof and cites [in brackets] the sections where they are discussed thoroughly. All of these ideas are

### The Prime Numbers. Definition. A prime number is a positive integer with exactly two positive divisors.

The Prime Numbers Before starting our study of primes, we record the following important lemma. Recall that integers a, b are said to be relatively prime if gcd(a, b) = 1. Lemma (Euclid s Lemma). If gcd(a,

### Matita 0.99.1. Andrea Asperti (Wilmer Ricciotti, Claudio Sacerdoti Coen)

Matita 0.99.1 Andrea Asperti (Wilmer Ricciotti, Claudio Sacerdoti Coen) Department of Computer Science, University of Bologna Mura Anteo Zamboni 7, 40127, Bologna, ITALY asperti@cs.unibo.it Foundation

### The countdown problem

JFP 12 (6): 609 616, November 2002. c 2002 Cambridge University Press DOI: 10.1017/S0956796801004300 Printed in the United Kingdom 609 F U N C T I O N A L P E A R L The countdown problem GRAHAM HUTTON

### Introduction to Automata Theory. Reading: Chapter 1

Introduction to Automata Theory Reading: Chapter 1 1 What is Automata Theory? Study of abstract computing devices, or machines Automaton = an abstract computing device Note: A device need not even be a

### Mathematical induction. Niloufar Shafiei

Mathematical induction Niloufar Shafiei Mathematical induction Mathematical induction is an extremely important proof technique. Mathematical induction can be used to prove results about complexity of

### Elementary Number Theory We begin with a bit of elementary number theory, which is concerned

CONSTRUCTION OF THE FINITE FIELDS Z p S. R. DOTY Elementary Number Theory We begin with a bit of elementary number theory, which is concerned solely with questions about the set of integers Z = {0, ±1,

### LAKE ELSINORE UNIFIED SCHOOL DISTRICT

LAKE ELSINORE UNIFIED SCHOOL DISTRICT Title: PLATO Algebra 1-Semester 2 Grade Level: 10-12 Department: Mathematics Credit: 5 Prerequisite: Letter grade of F and/or N/C in Algebra 1, Semester 2 Course Description:

### Discrete Mathematics and Probability Theory Fall 2009 Satish Rao, David Tse Note 2

CS 70 Discrete Mathematics and Probability Theory Fall 2009 Satish Rao, David Tse Note 2 Proofs Intuitively, the concept of proof should already be familiar We all like to assert things, and few of us

### Generating Elementary Combinatorial Objects

Fall 2009 Combinatorial Generation Combinatorial Generation: an old subject Excerpt from: D. Knuth, History of Combinatorial Generation, in pre-fascicle 4B, The Art of Computer Programming Vol 4. Combinatorial

### Data Structures CSC212 (1) Dr Muhammad Hussain Lecture - Binary Search Tree ADT

(1) Binary Search Tree ADT 56 26 200 18 28 190 213 12 24 27 (2) Binary Search Tree ADT (BST) It is a binary tree with the following properties 1. with each node associate a key 2. the key of each node

### Chapter 3. Cartesian Products and Relations. 3.1 Cartesian Products

Chapter 3 Cartesian Products and Relations The material in this chapter is the first real encounter with abstraction. Relations are very general thing they are a special type of subset. After introducing

### What's Wrong With Formal Programming Methods? Eric C.R. Hehner

What's Wrong With Formal Programming Methods? Eric C.R. Hehner Department of Computer Science, University of Toronto, Toronto M5S 1A4 Canada The January 1991 issue of Computing Research News includes the

### Class Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction

Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know

### Chapter 14 The Binary Search Tree

Chapter 14 The Binary Search Tree In Chapter 5 we discussed the binary search algorithm, which depends on a sorted vector. Although the binary search, being in O(lg(n)), is very efficient, inserting a

### Clicker Question. Theorems/Proofs and Computational Problems/Algorithms MC215: MATHEMATICAL REASONING AND DISCRETE STRUCTURES

MC215: MATHEMATICAL REASONING AND DISCRETE STRUCTURES Tuesday, 1/21/14 General course Information Sets Reading: [J] 1.1 Optional: [H] 1.1-1.7 Exercises: Do before next class; not to hand in [J] pp. 12-14:

### (0, 0) : order 1; (0, 1) : order 4; (0, 2) : order 2; (0, 3) : order 4; (1, 0) : order 2; (1, 1) : order 4; (1, 2) : order 2; (1, 3) : order 4.

11.01 List the elements of Z 2 Z 4. Find the order of each of the elements is this group cyclic? Solution: The elements of Z 2 Z 4 are: (0, 0) : order 1; (0, 1) : order 4; (0, 2) : order 2; (0, 3) : order

### MATH10040 Chapter 2: Prime and relatively prime numbers

MATH10040 Chapter 2: Prime and relatively prime numbers Recall the basic definition: 1. Prime numbers Definition 1.1. Recall that a positive integer is said to be prime if it has precisely two positive

### Automata and Formal Languages

Automata and Formal Languages Winter 2009-2010 Yacov Hel-Or 1 What this course is all about This course is about mathematical models of computation We ll study different machine models (finite automata,

### x < y iff x < y, or x and y are incomparable and x χ(x,y) < y χ(x,y).

12. Large cardinals The study, or use, of large cardinals is one of the most active areas of research in set theory currently. There are many provably different kinds of large cardinals whose descriptions

### Training for THE B METHOD. Level 1

Training for THE B METHOD Level 1 overview introduction to B a formal method with proofs the usage of B foundations benefits concepts of B B modules B components abstract machines refinements implementations

### Defining Functions on Equivalence Classes. Lawrence C. Paulson, Computer Laboratory, University of Cambridge

Defining Functions on Equivalence Classes Lawrence C. Paulson, Computer Laboratory, University of Cambridge Outline of Talk 1. Review of equivalence relations and quotients 2. General lemmas for defining

### Deterministic Discrete Modeling

Deterministic Discrete Modeling Formal Semantics of Firewalls in Isabelle/HOL Cornelius Diekmann, M.Sc. Dr. Heiko Niedermayer Prof. Dr.-Ing. Georg Carle Lehrstuhl für Netzarchitekturen und Netzdienste

### Chapter II. Controlling Cars on a Bridge

Chapter II. Controlling Cars on a Bridge 1 Introduction The intent of this chapter is to introduce a complete example of a small system development. During this development, you will be made aware of the

### Loop Invariants and Binary Search

Loop Invariants and Binary Search Chapter 4.3.3 and 9.3.1-1 - Outline Ø Iterative Algorithms, Assertions and Proofs of Correctness Ø Binary Search: A Case Study - 2 - Outline Ø Iterative Algorithms, Assertions

### Induction. Margaret M. Fleck. 10 October These notes cover mathematical induction and recursive definition

Induction Margaret M. Fleck 10 October 011 These notes cover mathematical induction and recursive definition 1 Introduction to induction At the start of the term, we saw the following formula for computing

### 2. Methods of Proof Types of Proofs. Suppose we wish to prove an implication p q. Here are some strategies we have available to try.

2. METHODS OF PROOF 69 2. Methods of Proof 2.1. Types of Proofs. Suppose we wish to prove an implication p q. Here are some strategies we have available to try. Trivial Proof: If we know q is true then

### God created the integers and the rest is the work of man. (Leopold Kronecker, in an after-dinner speech at a conference, Berlin, 1886)

Chapter 2 Numbers God created the integers and the rest is the work of man. (Leopold Kronecker, in an after-dinner speech at a conference, Berlin, 1886) God created the integers and the rest is the work

### Kevin James. MTHSC 412 Section 2.4 Prime Factors and Greatest Comm

MTHSC 412 Section 2.4 Prime Factors and Greatest Common Divisor Greatest Common Divisor Definition Suppose that a, b Z. Then we say that d Z is a greatest common divisor (gcd) of a and b if the following

### A first step towards modeling semistructured data in hybrid multimodal logic

A first step towards modeling semistructured data in hybrid multimodal logic Nicole Bidoit * Serenella Cerrito ** Virginie Thion * * LRI UMR CNRS 8623, Université Paris 11, Centre d Orsay. ** LaMI UMR

### Data Structures Fibonacci Heaps, Amortized Analysis

Chapter 4 Data Structures Fibonacci Heaps, Amortized Analysis Algorithm Theory WS 2012/13 Fabian Kuhn Fibonacci Heaps Lacy merge variant of binomial heaps: Do not merge trees as long as possible Structure:

### Automata Theory. Şubat 2006 Tuğrul Yılmaz Ankara Üniversitesi

Automata Theory Automata theory is the study of abstract computing devices. A. M. Turing studied an abstract machine that had all the capabilities of today s computers. Turing s goal was to describe the

### Lemma 5.2. Let S be a set. (1) Let f and g be two permutations of S. Then the composition of f and g is a permutation of S.

Definition 51 Let S be a set bijection f : S S 5 Permutation groups A permutation of S is simply a Lemma 52 Let S be a set (1) Let f and g be two permutations of S Then the composition of f and g is a

### GREATEST COMMON DIVISOR

DEFINITION: GREATEST COMMON DIVISOR The greatest common divisor (gcd) of a and b, denoted by (a, b), is the largest common divisor of integers a and b. THEOREM: If a and b are nonzero integers, then their

### Every tree contains a large induced subgraph with all degrees odd

Every tree contains a large induced subgraph with all degrees odd A.J. Radcliffe Carnegie Mellon University, Pittsburgh, PA A.D. Scott Department of Pure Mathematics and Mathematical Statistics University

### Mathematical Induction. Lecture 10-11

Mathematical Induction Lecture 10-11 Menu Mathematical Induction Strong Induction Recursive Definitions Structural Induction Climbing an Infinite Ladder Suppose we have an infinite ladder: 1. We can reach

### COMPUTER SCIENCE. Paper 1 (THEORY)

COMPUTER SCIENCE Paper 1 (THEORY) (Three hours) Maximum Marks: 70 (Candidates are allowed additional 15 minutes for only reading the paper. They must NOT start writing during this time) -----------------------------------------------------------------------------------------------------------------------

### A Persistent Union-Find Data Structure

A Persistent Union-Find Data Structure Sylvain Conchon Jean-Christophe Filliâtre LRI, Univ Paris-Sud, CNRS, Orsay F-91405 INRIA Futurs, ProVal, Parc Orsay Université, F-91893 {conchon,filliatr}@lri.fr

### COMMUTATIVE RINGS. Definition: A domain is a commutative ring R that satisfies the cancellation law for multiplication:

COMMUTATIVE RINGS Definition: A commutative ring R is a set with two operations, addition and multiplication, such that: (i) R is an abelian group under addition; (ii) ab = ba for all a, b R (commutative

### 6.2 Permutations continued

6.2 Permutations continued Theorem A permutation on a finite set A is either a cycle or can be expressed as a product (composition of disjoint cycles. Proof is by (strong induction on the number, r, of

### MAP-I Programa Doutoral em Informática. Rigorous Software Development

MAP-I Programa Doutoral em Informática Rigorous Software Development Unidade Curricular em Teoria e Fundamentos Theory and Foundations (UCTF) DI-UM, DCC-FCUP May, 2012 Abstract This text presents a UCTF

### Verifying security protocols using theorem provers

1562 2007 79-86 79 Verifying security protocols using theorem provers Miki Tanaka National Institute of Information and Communications Technology Koganei, Tokyo 184-8795, Japan Email: miki.tanaka@nict.go.jp

### Foundational Proof Certificates

An application of proof theory to computer science INRIA-Saclay & LIX, École Polytechnique CUSO Winter School, Proof and Computation 30 January 2013 Can we standardize, communicate, and trust formal proofs?

### CmSc 175 Discrete Mathematics Lesson 10: SETS A B, A B

CmSc 175 Discrete Mathematics Lesson 10: SETS Sets: finite, infinite, : empty set, U : universal set Describing a set: Enumeration = {a, b, c} Predicates = {x P(x)} Recursive definition, e.g. sequences

### Notes: Chapter 2 Section 2.2: Proof by Induction

Notes: Chapter 2 Section 2.2: Proof by Induction Basic Induction. To prove: n, a W, n a, S n. (1) Prove the base case - S a. (2) Let k a and prove that S k S k+1 Example 1. n N, n i = n(n+1) 2. Example

### Solutions to TOPICS IN ALGEBRA I.N. HERSTEIN. Part II: Group Theory

Solutions to TOPICS IN ALGEBRA I.N. HERSTEIN Part II: Group Theory No rights reserved. Any part of this work can be reproduced or transmitted in any form or by any means. Version: 1.1 Release: Jan 2013

### A simple type system with two identity types

A simple type system with two identity types Vladimir Voevodsky Started February 23, 201 Work in progress. 1 Introduction We call this system and its further extensions HTS for homotopy type system. It

### Scheduling Shop Scheduling. Tim Nieberg

Scheduling Shop Scheduling Tim Nieberg Shop models: General Introduction Remark: Consider non preemptive problems with regular objectives Notation Shop Problems: m machines, n jobs 1,..., n operations

### PART I. THE REAL NUMBERS

PART I. THE REAL NUMBERS This material assumes that you are already familiar with the real number system and the representation of the real numbers as points on the real line. I.1. THE NATURAL NUMBERS

### Formal Engineering for Industrial Software Development

Shaoying Liu Formal Engineering for Industrial Software Development Using the SOFL Method With 90 Figures and 30 Tables Springer Contents Introduction 1 1.1 Software Life Cycle... 2 1.2 The Problem 4 1.3

### Analysis of Algorithms I: Binary Search Trees

Analysis of Algorithms I: Binary Search Trees Xi Chen Columbia University Hash table: A data structure that maintains a subset of keys from a universe set U = {0, 1,..., p 1} and supports all three dictionary

### Regular Languages and Finite Automata

Regular Languages and Finite Automata 1 Introduction Hing Leung Department of Computer Science New Mexico State University Sep 16, 2010 In 1943, McCulloch and Pitts [4] published a pioneering work on a

### CS 103X: Discrete Structures Homework Assignment 3 Solutions

CS 103X: Discrete Structures Homework Assignment 3 s Exercise 1 (20 points). On well-ordering and induction: (a) Prove the induction principle from the well-ordering principle. (b) Prove the well-ordering

### Rigorous Software Engineering Hoare Logic and Design by Contracts

Rigorous Software Engineering Hoare Logic and Design by Contracts Simão Melo de Sousa RELEASE (UBI), LIACC (Porto) Computer Science Department University of Beira Interior, Portugal 2010-2011 S. Melo de

### CHAPTER 7 GENERAL PROOF SYSTEMS

CHAPTER 7 GENERAL PROOF SYSTEMS 1 Introduction Proof systems are built to prove statements. They can be thought as an inference machine with special statements, called provable statements, or sometimes

### P (A) = lim P (A) = N(A)/N,

1.1 Probability, Relative Frequency and Classical Definition. Probability is the study of random or non-deterministic experiments. Suppose an experiment can be repeated any number of times, so that we

### 1 Operational Semantics for While

Models of Computation, 2010 1 1 Operational Semantics for While The language While of simple while programs has a grammar consisting of three syntactic categories: numeric expressions, which represent