Question

1. Design and code a state diagram to recognize the floating-point literals, integer literals, string literals and variable names of your favorite programming language.

2. Write an EBNF or BNF for boolean expressions, assignment statements, and mathematical/logical operations in Java.

3. Find an example of a loop, show the steps to prove its correctness. Explain in detail why each step is necessary.

4. In a letter to the editor of CACM, Rubin (1987) uses the following code segment as evidence that the readability of some code with gotos is better than the equivalent code without gotos. This code finds the first row of an n by n integer matrix named x that has nothing but zero values.

for (i = 1; i <= n; i++) {

for (j = 1; j <= n; j++)

if (x[i][j] != 0)

goto reject;

println (’First all-zero row is:’, i);

break;

reject:

}

Answer 1

1. State Diagram:

2. EBNF or BNF in Java

<constant expression> ::= <expression>

<expression> ::= <assignment expression>

<assignment expression> ::= <conditional expression> | <assignment>

<assignment> ::= <left hand side> <assignment operator> <assignment expression>

<left hand side> ::= <expression name> | <field access> | <array access>

<assignment operator> ::= = | *= | /= | %= | += | -= | <<= | >>= | >>>= | &= | ^= | |=

<conditional expression> ::= <conditional or expression> | <conditional or expression> ? <expression> : <conditional expression>

<conditional or expression> ::= <conditional and expression> | <conditional or expression> || <conditional and expression>

<conditional and expression> ::= <inclusive or expression> | <conditional and expression> && <inclusive or expression>

<inclusive or expression> ::= <exclusive or expression> | <inclusive or expression> | <exclusive or expression>

<exclusive or expression> ::= <and expression> | <exclusive or expression> ^ <and expression>

<and expression> ::= <equality expression> | <and expression> & <equality expression>

<equality expression> ::= <relational expression> | <equality expression> == <relational expression> | <equality expression> != <relational expression>

<relational expression> ::= <shift expression> | <relational expression> < <shift expression> | <relational expression> > <shift expression> | <relational expression> <= <shift expression> | <relational expression> >= <shift expression> | <relational expression> instanceof <reference type>

<shift expression> ::= <additive expression> | <shift expression> << <additive expression> | <shift expression> >> <additive expression> | <shift expression> >>> <additive expression>

<additive expression> ::= <multiplicative expression> | <additive expression> + <multiplicative expression> | <additive expression> - <multiplicative expression>

<multiplicative expression> ::= <unary expression> | <multiplicative expression> * <unary expression> | <multiplicative expression> / <unary expression> | <multiplicative expression> % <unary expression>

<cast expression> ::= ( <primitive type> ) <unary expression> | ( <reference type> ) <unary expression not plus minus>

<unary expression> ::= <preincrement expression> | <predecrement expression> | + <unary expression> | - <unary expression> | <unary expression not plus minus>

<predecrement expression> ::= -- <unary expression>

<preincrement expression> ::= ++ <unary expression>

<unary expression not plus minus> ::= <postfix expression> | ~ <unary expression> | ! <unary expression> | <cast expression>

<postdecrement expression> ::= <postfix expression> --

<postincrement expression> ::= <postfix expression> ++

<postfix expression> ::= <primary> | <expression name> | <postincrement expression> | <postdecrement expression>

<method invocation> ::= <method name> ( <argument list>? ) | <primary> . <identifier> ( <argument list>? ) | super . <identifier> ( <argument list>? )

<field access> ::= <primary> . <identifier> | super . <identifier>

<primary> ::= <primary no new array> | <array creation expression>

<primary no new array> ::= <literal> | this | ( <expression> ) | <class instance creation expression> | <field access> | <method invocation> | <array access>

<class instance creation expression> ::= new <class type> ( <argument list>? )

<argument list> ::= <expression> | <argument list> , <expression>

<array creation expression> ::= new <primitive type> <dim exprs> <dims>? | new <class or interface type> <dim exprs> <dims>?

<dim exprs> ::= <dim expr> | <dim exprs> <dim expr>

<dim expr> ::= [ <expression> ]

<dims> ::= [ ] | <dims> [ ]

<array access> ::= <expression name> [ <expression> ] | <primary no new array> [ <expression>]

3.

Loop invariants

Induction is the method of choice for analyzing properties of algorithms with loops. A typical such algorithm:

Initialization The algorithm initializes some variables based on the inputs.

Loop Then the loop starts. Each iteration of the loop changes variables ac- cording to some loop instructions until a guard condition fails.

Produce Output When the guard condition fails, the algorithm then pro- duces some output based on the values of the variables.

There are many things we want to know about such algorithms. How does the output depend on the input, and why does it meet the correctness property in the problem specification? Does the loop always terminate? How many iterations might the loop make, and how much total time does it take?

All of these are about global behavior of the algorithm, properties of the entire run. But what the algorithm description gives us is local behavior, what happens in each step. Loop invariants allow us to bridge this gap.

To understand the global behavior, when all we are given explicitly is the local, we usually need to prove something stronger than what happens at the end. We need to understand what happens in the middle, something about the values of the variables after t steps. Sometimes there’s an explicit formula telling us this. But more typically, the art of finding the right loop invariant is to get a property that is simple enough to understand but captures the reason why the algorithm is making progress towards terminating with the correct answer.

So far we’ve been very abstract. Let’s translate this to a specific example.

Here’s a very simple algorithm that computes the ceiling of the log of x.

LogRounded (x: integer): integer

1. i ← 0

2. y ← 1

3. IF x ≤ 0then Return “error”

4. While y < x do:

5. i ← i + 1

6. y ← 2 ∗ y

7. Return i

We want to show that the program outputs log₂x rounded up to the nearest integer. But to do this we need to prove a stronger claim about the values y and i have throughout the loop. In this case, there is an explicit formula. Each time we go through the loop, i is incremented, and y doubles. So y will always be a power of 2. We will show y = 2ⁱ at all times. Note that this loop invariant isn’t just a translation of the definition of correctness. But it really is why the algorithm was designed the way it was, the explanation for why we are following these steps.

The proof breaks down into three basic parts, based on the three parts of a loop: Initialization, Looping, Returning Output.

Stating the invariant In this example, we are claiming that, if the loop exe- cutes at least t times, after the t’th iteration, y = 2ⁱ.

The base case Before the loop starts, i.e., after t = 0 iterations, y = 1 and i = 0. Since 2⁰ = 1, the invariant is true at the start.

Induction step Let y_B and i_B be the values of y and i at the end of the t’th interation (i.e, at the beginning of the t + 1’st iteration). B stands for “before” the t + 1’st iteration. Let y_A and i_A be the values of y and i at the end of the t+1’st interation. A stands for “after” the t+1’st iteration.

Assume the loop invariant holds at the end of the t’th iteration, that is, that y_B = 2ⁱB . This is the induction hypothesis.

In that iteration, y is doubled and i is incremented, so the new value of y is y_A = 2y_B and the new value of i is i_A = i_B + 1.

Then, from the algorithm, we have

y_A = 2y_B

= 2 ∗ 2ⁱB

= 2i_B+1

= 2ⁱA

Thus, at the end of the t + 1’st iteration, y = 2ⁱ as desired.

Summary of induction argument Since the invariant is true after t = 0 iterations, and if it is true after t iterations it is also true after t + 1 iterations, by induction, it will remain true after any number of iterations until the loop ends.

Using the invariant to prove correctness The guard condition is that y <x. Consider the last iteration of this loop, and as before let y_B, i_Bbe the values of y and i before this iteration, and y_A= 2y_Band i_A= i_B+ 1 be the values after this iteration. Before the last iteration , y_B < x because the guard condition is still true. Afterwards, the new value of y, y_Ahas y_A≥ x because this is the last time through the loop, which means the guard condition is false when it ends. Since y_A= 2y_B, y_B < x ≤ 2y_B. Using the loop invariant, y_B= 2ⁱB . So 2ⁱB < x ≤ 2ⁱB +1. Since i_B+1 = i_A, this means 2ⁱA−1  < x ≤ 2ⁱA . Taking logs, i_A− 1 < log₂x < i_A. Thus, i_Ais the closest integer greater than log2 x. The algorithm then returns i_A= |log2 x|.

4. Question is incomplete.