# Hoare2Hoare Logic, Part II

On a piece of paper, write down a specification (as a Hoare triple) for the following program:
X ::= 2;;
Y ::= X + X

Write down a (useful) specification for the following program:
X ::= X + 1;; Y ::= X + 1

Write down a (useful) specification for the following program:
TEST XY
THEN SKIP
ELSE
Z ::= X;;
X ::= Y;;
Y ::= Z
FI

Write down a (useful) specification for the following program:
X ::= m;;
Z ::= 0;;
WHILE ~(X = 0) DO
X ::= X - 2;;
Z ::= Z + 1
END

# Decorated Programs

The beauty of Hoare Logic is that it is compositional: the structure of proofs exactly follows the structure of programs.
This suggests that we can record the essential ideas of a proof (informally, and leaving out some low-level calculational details) by "decorating" a program with appropriate assertions on each of its commands.
Such a decorated program carries within it an argument for its own correctness.
For example, consider the program:
WHILE ~(X = 0) DO
Z ::= Z - 1;;
X ::= X - 1
END
Here is one possible specification for this program:
{{ X = mZ = p }}
WHILE ~(X = 0) DO
Z ::= Z - 1;;
X ::= X - 1
END
{{ Z = p - m }}
Note the parameters m and p, which stand for fixed-but-arbitrary numbers. Formally, they are simply Coq variables of type nat. Here is a decorated version of the program, embodying a proof of this specification:
{{ X = mZ = p }} ->>
{{ Z - X = p - m }}
WHILE ~(X = 0) DO
{{ Z - X = p - mX ≠ 0 }} ->>
{{ (Z - 1) - (X - 1) = p - m }}
Z ::= Z - 1;;
{{ Z - (X - 1) = p - m }}
X ::= X - 1
{{ Z - X = p - m }}
END
{{ Z - X = p - m ∧ ¬(X ≠ 0) }} ->>
{{ Z = p - m }}
Concretely, a decorated program consists of the program text interleaved with assertions (either a single assertion or possibly two assertions separated by an implication).
To check that a decorated program represents a valid proof, we check that each individual command is locally consistent with its nearby assertions in the following sense:
• SKIP is locally consistent if its precondition and postcondition are the same:
{{ P }} SKIP {{ P }}
• The sequential composition of c1 and c2 is locally consistent (with respect to assertions P and R) if c1 is locally consistent (with respect to P and Q) and c2 is locally consistent (with respect to Q and R):
{{ P }} c1;; {{ Q }} c2 {{ R }}
• An assignment is locally consistent if its precondition is the appropriate substitution of its postcondition:
{{ P [X > a] }}
X ::= a
{{ P }}
• A conditional is locally consistent (with respect to assertions P and Q) if the assertions at the top of its "then" and "else" branches are exactly P b and P ¬b and if its "then" branch is locally consistent (with respect to P b and Q) and its "else" branch is locally consistent (with respect to P ¬b and Q):
{{ P }}
TEST b THEN
{{ Pb }}
c1
{{ Q }}
ELSE
{{ P ∧ ¬b }}
c2
{{ Q }}
FI
{{ Q }}
• A while loop with precondition P is locally consistent if its postcondition is P ¬b, if the pre- and postconditions of its body are exactly P b and P, and if its body is locally consistent:
{{ P }}
WHILE b DO
{{ Pb }}
c1
{{ P }}
END
{{ P ∧ ¬b }}
• A pair of assertions separated by ->> is locally consistent if the first implies the second:
{{ P }} ->>
{{ P' }}
This corresponds to the application of hoare_consequence, and it is the only place in a decorated program where checking whether decorations are correct is not fully mechanical and syntactic, but rather may involve logical and/or arithmetic reasoning.

## Example: Swapping Using Addition and Subtraction

Here is a program that swaps the values of two variables using addition and subtraction (instead of by assigning to a temporary variable).
X ::= X + Y;;
Y ::= X - Y;;
X ::= X - Y
We can prove (informally) using decorations that this program is correct -- i.e., it always swaps the values of variables X and Y.
(* WORK IN CLASS *)

## Example: Simple Conditionals

Here's a simple program using conditionals, with a possible specification:
{{ True }}
TEST XY THEN
Z ::= Y - X
ELSE
Z ::= X - Y
FI
{{ Z + X = YZ + Y = X }}
Let's turn it into a decorated program...
(* WORK IN CLASS *)

## Example: Reduce to Zero

Here is a very simple WHILE loop with a simple specification:
{{ True }}
WHILE ~(X = 0) DO
X ::= X - 1
END
{{ X = 0 }}
(* WORK IN CLASS *)
From an informal proof in the form of a decorated program, it is easy to read off a formal proof using the Coq versions of the Hoare rules. Note that we do not unfold the definition of hoare_triple anywhere in this proof -- the idea is to use the Hoare rules as a self-contained logic for reasoning about programs.

Definition reduce_to_zero' : com :=
WHILE ~(X = 0) DO
X ::= X - 1
END.

Theorem reduce_to_zero_correct' :
{{True}}
reduce_to_zero'
{{X = 0}}.
Proof.
unfold reduce_to_zero'.
(* First we need to transform the postcondition so
that hoare_while will apply. *)

eapply hoare_consequence_post.
- apply hoare_while.
+ (* Loop body preserves invariant *)
(* Need to massage precondition before hoare_asgn applies *)
eapply hoare_consequence_pre.
× apply hoare_asgn.
× (* Proving trivial implication (2) ->> (3) *)
unfold assn_sub, "->>". simpl. intros. exact I.
- (* Invariant and negated guard imply postcondition *)
intros st [Inv GuardFalse].
unfold bassn in GuardFalse. simpl in GuardFalse.
rewrite not_true_iff_false in GuardFalse.
rewrite negb_false_iff in GuardFalse.
apply eqb_eq in GuardFalse.
apply GuardFalse.
Qed.
In Hoare we introduced a series of tactics named assn_auto to automate proofs involving just assertions. We can try using the most advanced of those tactics to streamline the previous proof:

Theorem reduce_to_zero_correct'' :
{{True}}
reduce_to_zero'
{{X = 0}}.
Proof.
unfold reduce_to_zero'.
eapply hoare_consequence_post.
- apply hoare_while.
+ eapply hoare_consequence_pre.
× apply hoare_asgn.
× assn_auto''.
- assn_auto''. (* doesn't succeed *)
Abort.
Automation to the rescue!

Ltac verify_assn :=
repeat split;
simpl; unfold assert_implies;
unfold ap in *; unfold ap2 in *;
unfold bassn in *; unfold beval in *; unfold aeval in *;
unfold assn_sub; intros;
repeat (simpl in *;
rewrite t_update_eq ||
(try rewrite t_update_neq; [| (intro X; inversion X; fail)]));
simpl in *;
repeat match goal with [H : ___] ⇒ destruct H end;
repeat rewrite not_true_iff_false in *;
repeat rewrite not_false_iff_true in *;
repeat rewrite negb_true_iff in *;
repeat rewrite negb_false_iff in *;
repeat rewrite eqb_eq in *;
repeat rewrite eqb_neq in *;
repeat rewrite leb_iff in *;
repeat rewrite leb_iff_conv in *;
try subst;
simpl in *;
repeat
match goal with
[st : state_] ⇒
match goal with
| [H : st _ = __] ⇒ rewriteH in *; clear H
| [H : _ = st __] ⇒ rewrite <- H in *; clear H
end
end;
try eauto; try omega.
All that automation makes it easy to verify reduce_to_zero':

Theorem reduce_to_zero_correct''' :
{{True}}
reduce_to_zero'
{{X = 0}}.
Proof.
unfold reduce_to_zero'.
eapply hoare_consequence_post.
- apply hoare_while.
+ eapply hoare_consequence_pre.
× apply hoare_asgn.
× verify_assn.
- verify_assn.
Qed.

## Example: Division

The following Imp program calculates the integer quotient and remainder of parameters m and n.
X ::= m;;
Y ::= 0;;
WHILE nX DO
X ::= X - n;;
Y ::= Y + 1
END;
If we replace m and n by numbers and execute the program, it will terminate with the variable X set to the remainder when m is divided by n and Y set to the quotient. Here's a possible specification:
{{ True }}
X ::= m;;
Y ::= 0;;
WHILE nX DO
X ::= X - n;;
Y ::= Y + 1
END
{{ n × Y + X = mX < n }}

(* WORK IN CLASS *)

# Finding Loop Invariants

Once the outer pre- and postcondition are chosen, the only creative part in verifying programs using Hoare Logic is finding the right loop invariants...

## Example: Slow Subtraction

The following program subtracts the value of X from the value of Y by repeatedly decrementing both X and Y. We want to verify its correctness with respect to the pre- and postconditions shown:
{{ X = mY = n }}
WHILE ~(X = 0) DO
Y ::= Y - 1;;
X ::= X - 1
END
{{ Y = n - m }}
To verify this program, we need to find an invariant Inv for the loop. As a first step we can leave Inv as an unknown and build a skeleton for the proof by applying the rules for local consistency (working from the end of the program to the beginning, as usual, and without any thinking at all yet).
This leads to the following skeleton:
(1) {{ X = mY = n }} ->> (a)
(2) {{ Inv }}
WHILE ~(X = 0) DO
(3) {{ InvX ≠ 0 }} ->> (c)
(4) {{ Inv [X > X-1] [Y > Y-1] }}
Y ::= Y - 1;;
(5) {{ Inv [X > X-1] }}
X ::= X - 1
(6) {{ Inv }}
END
(7) {{ Inv ∧ ¬(X ≠ 0) }} ->> (b)
(8) {{ Y = n - m }}
By examining this skeleton, we can see that any valid Inv will have to respect three conditions:
• (a) it must be weak enough to be implied by the loop's precondition, i.e., (1) must imply (2);
• (b) it must be strong enough to imply the program's postcondition, i.e., (7) must imply (8);
• (c) it must be preserved by each iteration of the loop (given that the loop guard evaluates to true), i.e., (3) must imply (4).

(* WORK IN CLASS *)

## Example: Parity

Here is a cute little program for computing the parity of the value initially stored in X (due to Daniel Cristofani).
{{ X = m }}
WHILE 2 ≤ X DO
X ::= X - 2
END
{{ X = parity m }}
The mathematical parity function used in the specification is defined in Coq as follows:

Fixpoint parity x :=
match x with
| 0 ⇒ 0
| 1 ⇒ 1
| S (S x') ⇒ parity x'
end.

(* WORK IN CLASS *)

## Example: Finding Square Roots

The following program computes the (integer) square root of X by naive iteration:
{{ X=m }}
Z ::= 0;;
WHILE (Z+1)*(Z+1) ≤ X DO
Z ::= Z+1
END
{{ Z×Zmm<(Z+1)*(Z+1) }}

(* WORK IN CLASS *)

## Example: Squaring

Here is a program that squares X by repeated addition:
{{ X = m }}
Y ::= 0;;
Z ::= 0;;
WHILE ~(Y = X) DO
Z ::= Z + X;;
Y ::= Y + 1
END
{{ Z = m×m }}

(* WORK IN CLASS *)

With a little more work, we can formalize the definition of well-formed decorated programs and mostly automate the mechanical steps when filling in decorations...

## Syntax

Decorated commands contain assertions mostly just as postconditions, omitting preconditions where possible and letting the context supply them.
The alternative--decorating every command with both a pre- and postcondition--would be too heavyweight. E.g., SKIP;; SKIP would become:
{{P}} ({{P}} SKIP {{P}}) ;; ({{P}} SKIP {{P}}) {{P}},
Specifically, we decorate as follows:
• Command SKIP is decorated only with its postcondition, as SKIP {{ Q }}.
• Sequence d1;; d2 contains no additional decoration. Inside d2 there will be a postcondition; that serves as the postcondition of d1;; d2. Inside d1 there will also be a postcondition; it additionally serves as the precondition for d2.
• Assignment X ::= a is decorated only with its postcondition, as X ::= a {{ Q }}.
• If statement TEST b THEN d1 ELSE d2 is decorated with a postcondition for the entire statement, as well as preconditions for each branch, as TEST b THEN {{ P1 }} d1 ELSE {{ P2 }} d2 FI {{ Q }}.
• While loop WHILE b DO d END is decorated with its postcondition and a precondition for the body, as WHILE b DO {{ P }} d END {{ Q }}. The postcondition inside d serves as the loop invariant.
• Implications ->> are added as decorations for a precondition as ->> {{ P }} d, or for a postcondition as d ->> {{ Q }}. The former is waiting for another precondition to eventually be supplied, e.g., {{ P'}} ->> {{ P }} d, and the latter relies on the postcondition already embedded in d.

Inductive dcom : Type :=
| DCSkip (Q : Assertion)
(* SKIP {{ Q }} *)
| DCSeq (d1 d2 : dcom)
(* d1 ;; d2 *)
| DCAsgn (X : string) (a : aexp) (Q : Assertion)
(* X := a {{ Q }} *)
| DCIf (b : bexp) (P1 : Assertion) (d1 : dcom)
(P2 : Assertion) (d2 : dcom) (Q : Assertion)
(* TEST b THEN {{ P1 }} d1 ELSE {{ P2 }} d2 FI {{ Q }} *)
| DCWhile (b : bexp) (P : Assertion) (d : dcom) (Q : Assertion)
(* WHILE b DO {{ P }} d END {{ Q }} *)
| DCPre (P : Assertion) (d : dcom)
(* ->> {{ P }} d *)
| DCPost (d : dcom) (Q : Assertion)
(* d ->> {{ Q }} *)
.
DCPre is used to provide the weakened precondition from the rule of consequence. To provide the initial precondition at the very top of the program, we use Decorated:

Inductive decorated : Type :=
| Decorated : Assertiondcomdecorated.
To avoid clashing with the existing Notation definitions for ordinary commands, we introduce these notations in a special scope called dcom_scope, and we Open this scope for the remainder of the file.

Notation "'SKIP' {{ P }}"
:= (DCSkip P)
(at level 10) : dcom_scope.
Notation "l '::=' a {{ P }}"
:= (DCAsgn l a P)
(at level 60, a at next level) : dcom_scope.
Notation "'WHILE' b 'DO' {{ Pbody }} d 'END' {{ Ppost }}"
:= (DCWhile b Pbody d Ppost)
(at level 80, right associativity) : dcom_scope.
Notation "'TEST' b 'THEN' {{ P }} d 'ELSE' {{ P' }} d' 'FI' {{ Q }}"
:= (DCIf b P d P' d' Q)
(at level 80, right associativity) : dcom_scope.
Notation "'->>' {{ P }} d"
:= (DCPre P d)
(at level 90, right associativity) : dcom_scope.
Notation "d '->>' {{ P }}"
:= (DCPost d P)
(at level 80, right associativity) : dcom_scope.
Notation " d ;; d' "
:= (DCSeq d d')
(at level 80, right associativity) : dcom_scope.
Notation "{{ P }} d"
:= (Decorated P d)
(at level 90) : dcom_scope.

Delimit Scope dcom_scope with dcom.
Open Scope dcom_scope.

Example dec0 :=
SKIP {{ True }}.
Example dec1 :=
WHILE true DO {{ True }} SKIP {{ True }} END
{{ True }}.
An example decorated program that decrements X to 0:

Example dec_while : decorated :=
{{ True }}
WHILE ~(X = 0)
DO
{{ True ∧ (X ≠ 0) }}
X ::= X - 1
{{ True }}
END
{{ TrueX = 0}} ->>
{{ X = 0 }}.
It is easy to go from a dcom to a com by erasing all annotations.

Fixpoint extract (d : dcom) : com :=
match d with
| DCSkip _SKIP
| DCSeq d1 d2 ⇒ (extract d1 ;; extract d2)
| DCAsgn X a _X ::= a
| DCIf b _ d1 _ d2 _TEST b THEN extract d1 ELSE extract d2 FI
| DCWhile b _ d _WHILE b DO extract d END
| DCPre _ dextract d
| DCPost d _extract d
end.

Definition extract_dec (dec : decorated) : com :=
match dec with
| Decorated P dextract d
end.

Example extract_while_ex :
extract_dec dec_while = (WHILE ¬X = 0 DO X ::= X - 1 END)%imp.
Proof.
unfold dec_while.
reflexivity.
Qed.
It is straightforward to extract the precondition and postcondition from a decorated program.

Fixpoint post (d : dcom) : Assertion :=
match d with
| DCSkip PP
| DCSeq d1 d2post d2
| DCAsgn X a QQ
| DCIf _ _ d1 _ d2 QQ
| DCWhile b Pbody c PpostPpost
| DCPre _ dpost d
| DCPost c QQ
end.

Definition pre_dec (dec : decorated) : Assertion :=
match dec with
| Decorated P dP
end.

Definition post_dec (dec : decorated) : Assertion :=
match dec with
| Decorated P dpost d
end.

Example pre_dec_while : pre_dec dec_while = True.
Proof. reflexivity. Qed.

Example post_dec_while : post_dec dec_while = (X = 0)%assertion.
Proof. reflexivity. Qed.
When is a decorated program correct?

Definition dec_correct (dec : decorated) :=
{{pre_dec dec}} (extract_dec dec) {{post_dec dec}}.

Example dec_while_triple_correct :
dec_correct dec_while
= {{ True }}
(WHILE ~(X = 0) DO X ::= X - 1 END)%imp
{{ X = 0 }}.
Proof. reflexivity. Qed.
To check whether this Hoare triple is valid, we need a way to extract the "proof obligations" from a decorated program. These obligations are often called verification conditions, because they are the facts that must be verified to see that the decorations are logically consistent and thus constitute a proof of correctness.

## Extracting Verification Conditions

The function verification_conditions takes a dcom d together with a precondition P and returns a proposition that, if it can be proved, implies that the triple {{P}} (extract d) {{post d}} is valid. It does this by walking over d and generating a big conjunction that includes
• all the local consistency checks
• many uses of ->> to bridge the gap between (i) assertions found inside decorated commands and (ii) assertions used by the local consistency checks. These uses correspond applications of the consequence rule.

Fixpoint verification_conditions (P : Assertion) (d : dcom) : Prop :=
match d with
| DCSkip Q
(P ->> Q)
| DCSeq d1 d2
verification_conditions P d1
∧ verification_conditions (post d1) d2
| DCAsgn X a Q
(P ->> Q [X > a])
| DCIf b P1 d1 P2 d2 Q
((Pb) ->> P1)%assertion
∧ ((P ∧ ¬b) ->> P2)%assertion
∧ (post d1 ->> Q) ∧ (post d2 ->> Q)
∧ verification_conditions P1 d1
∧ verification_conditions P2 d2
| DCWhile b Pbody d Ppost
(* post d is the loop invariant and the initial
precondition *)

(P ->> post d)
∧ ((post db) ->> Pbody)%assertion
∧ ((post d ∧ ¬b) ->> Ppost)%assertion
∧ verification_conditions Pbody d
| DCPre P' d
(P ->> P') ∧ verification_conditions P' d
| DCPost d Q
verification_conditions P d ∧ (post d ->> Q)
end.
And now the key theorem, stating that verification_conditions does its job correctly. Not surprisingly, we need to use each of the Hoare Logic rules at some point in the proof.

Theorem verification_correct : d P,
verification_conditions P d{{P}} (extract d) {{post d}}.
Proof.
induction d; intros; simpl in ×.
- (* Skip *)
eapply hoare_consequence_pre.
+ apply hoare_skip.
+ assumption.
- (* Seq *)
destruct H as [H1 H2].
eapply hoare_seq.
+ apply IHd2. apply H2.
+ apply IHd1. apply H1.
- (* Asgn *)
eapply hoare_consequence_pre.
+ apply hoare_asgn.
+ assumption.
- (* If *)
destruct H as [HPre1 [HPre2 [Hd1 [Hd2 [HThen HElse]]]]].
apply IHd1 in HThen. clear IHd1.
apply IHd2 in HElse. clear IHd2.
apply hoare_if.
+ eapply hoare_consequence; eauto.
+ eapply hoare_consequence; eauto.
- (* While *)
destruct H as [Hpre [Hbody1 [Hpost1 Hd]]].
eapply hoare_consequence; eauto.
apply hoare_while.
eapply hoare_consequence_pre; eauto.
- (* Pre *)
destruct H as [HP Hd].
eapply hoare_consequence_pre; eauto.
- (* Post *)
destruct H as [Hd HQ].
eapply hoare_consequence_post; eauto.
Qed.
Now that all the pieces are in place, we can verify an entire program.

Definition verification_conditions_dec (dec : decorated) : Prop :=
match dec with
| Decorated P dverification_conditions P d
end.

Corollary verification_correct_dec : dec,
verification_conditions_dec decdec_correct dec.
Proof.
intros [P d]. apply verification_correct.
Qed.
The propositions generated by verification_conditions are fairly big, and they contain many conjuncts that are essentially trivial. Our verify_assn can often take care of them.

Example vc_dec_while :
verification_conditions_dec dec_while =
((((fun _ : stateTrue) ->> (fun _ : stateTrue)) ∧
((fun st : stateTruenegb (st X =? 0) = true) ->>
(fun st : stateTruest X ≠ 0)) ∧
((fun st : stateTruenegb (st X =? 0) ≠ true) ->>
(fun st : stateTruest X = 0)) ∧
(fun st : stateTruest X ≠ 0) ->> (fun _ : stateTrue) [X > X - 1]) ∧
(fun st : stateTruest X = 0) ->> (fun st : statest X = 0)).
Proof. verify_assn. Qed.

## Automation

To automate the entire process of verification, we can use verification_correct to extract the verification conditions, then use verify_assn to verify them (if it can).
Ltac verify :=
intros;
apply verification_correct;
verify_assn.

Theorem dec_while_correct :
dec_correct dec_while.
Proof. verify. Qed.
Let's use that automation to verify formal decorated programs corresponding to informal ones we have seen.

### Slow Subtraction

Example subtract_slowly_dec (m : nat) (p : nat) : decorated :=
{{ X = mZ = p }} ->>
{{ Z - X = p - m }}
WHILE ~(X = 0)
DO {{ Z - X = p - mX ≠ 0 }} ->>
{{ (Z - 1) - (X - 1) = p - m }}
Z ::= Z - 1
{{ Z - (X - 1) = p - m }} ;;
X ::= X - 1
{{ Z - X = p - m }}
END
{{ Z - X = p - mX = 0 }} ->>
{{ Z = p - m }}.

Theorem subtract_slowly_dec_correct : m p,
dec_correct (subtract_slowly_dec m p).
Proof. verify. (* this grinds for a bit! *) Qed.

### Swapping Using Addition and Subtraction

Definition swap : com :=
X ::= X + Y;;
Y ::= X - Y;;
X ::= X - Y.

Definition swap_dec (m n:nat) : decorated :=
{{ X = mY = n}} ->>
{{ (X + Y) - ((X + Y) - Y) = n
∧ (X + Y) - Y = m }}
X ::= X + Y
{{ X - (X - Y) = nX - Y = m }};;
Y ::= X - Y
{{ X - Y = nY = m }};;
X ::= X - Y
{{ X = nY = m}}.

Theorem swap_correct : m n,
dec_correct (swap_dec m n).
Proof. verify. Qed.
See the full version of the chapter for the rest...