Polynomial evaluation in Isabelle

Question

In the book Concrete Semantics, exercise 2.11 writes:

Define arithmetic expressions in one variable over integers (type int) as a data type:

datatype exp = Var | Const int | Add exp exp | Mult exp exp

Define a function eval :: exp ⇒ int ⇒ int such that eval e x evaluates e at the value x. A polynomial can be represented as a list of coefficients, starting with the constant. For example, [4, 2, − 1, 3] represents the polynomial 4+2x−x 2 +3x 3 . Define a function evalp :: int list ⇒ int ⇒ int that evaluates a polynomial at the given value. Define a function coeffs :: exp ⇒ int list that transforms an expression into a polynomial. This may require auxiliary functions. Prove that coeffs preserves the value of the expression: evalp (coeffs e) x = eval e x. Hint: consider the hint in Exercise 2.10.

As a first try, and because former exercises encouraged to write iterative versions of functions, I wrote the following:

datatype exp = Var | Const int | Add exp exp | Mult exp exp

fun eval :: "exp ⇒ int ⇒ int" where
  "eval Var x = x"
| "eval (Const n) _ = n"
| "eval (Add e1 e2) x = (eval e1 x) + (eval e2 x)"
| "eval (Mult e1 e2) x = (eval e1 x) * (eval e2 x)"

fun evalp_it :: "int list ⇒ int ⇒ int ⇒ int ⇒ int" where
  "evalp_it [] x xpwr acc = acc"
| "evalp_it (c # cs) x xpwr acc = evalp_it cs x (xpwr*x) (acc + c*xpwr)" 

fun evalp :: "int list ⇒ int ⇒ int" where
  "evalp coeffs x = evalp_it coeffs x 1 0"

fun add_coeffs :: "int list ⇒ int list ⇒ int list" where
  "add_coeffs [] [] = []"
| "add_coeffs (a # as) (b# bs) = (a+b) # (add_coeffs as bs)"
| "add_coeffs as [] = as"
| "add_coeffs [] bs = bs"

(there might be some zip function to do this)

fun mult_coeffs_it :: "int list ⇒ int list ⇒ int list ⇒ int list ⇒ int list" where
  "mult_coeffs_it [] bs accs zeros = accs"
| "mult_coeffs_it (a#as) bs accs zeros = 
     mult_coeffs_it as bs (add_coeffs accs zeros@bs) (0#zeros)"

fun mult_coeffs :: "int list ⇒ int list ⇒ int list" where
  "mult_coeffs as bs = mult_coeffs_it as bs [] []" 

fun coeffs :: "exp ⇒ int list" where 
  "coeffs (Var) = [0,1]"
| "coeffs (Const n) = [n]"
| "coeffs (Add e1 e2) = add_coeffs (coeffs e1) (coeffs e2)"
| "coeffs (Mult e1 e2) = mult_coeffs (coeffs e1) (coeffs e2)"

I tried to verify the sought theorem

lemma evalp_coeffs_eval: "evalp (coeffs e) x = eval e x"

but could not. Once I got an advice that writing good definitions is very important in theorem proving, though the adviser did not give details.

So, what is the problem with my definitions, conceptually? Please do not write the good definitions but point out the conceptual problems with my definitions.

UPDATE: upon advice I started to use

fun evalp2 :: "int list ⇒ int ⇒ int" where
"evalp2 [] v = 0"|
"evalp2 (p#ps) v = p + v * (evalp2 ps v) "

and looking into src/HOL/Algebra/Polynomials.thy I formulated

fun add_cffs :: "int list ⇒ int list ⇒ int list" where
  "add_cffs as bs = 
     ( if length as ≥ length bs
         then map2 (+) as (replicate (length as - length bs) 0) @ bs
         else add_cffs bs as)"

but that did not help much, simp add: algebra_simps or arith did not solve the corresponding subgoal.

score 1 · Answer 1 · answered Jan 29 '20 at 15:08

Some hints:

Try running quickcheck and nitpick on the Lemma until no more counter example is found. For the Lemma in your question I get the following counter example:
```
Quickcheck found a counterexample:
  e = Mult Var Var
  x = - 2
Evaluated terms:
  evalp (coeffs e) x = - 10
  eval e x = 4
```
Try to prove some useful Lemmas about your auxiliary functions first. For example:
```
lemma "evalp (mult_coeffs A B) x = evalp A x * evalp B x"
```
Read about calculating with polynomials (e.g. https://en.wikipedia.org/wiki/Polynomial_ring) and choose definitions close to what mathematicians do. Although this one might spoil the fun of coming up with a definition on your own.

Polynomial evaluation in Isabelle

1 Answers1