通过多个清单进行归纳证明

Question

我正在听有关Coursera的Scala中的Functional Programming in Scala讲座，在视频5.7的结尾，Martin Odersky要求通过归纳证明以下等式的正确性：

(xs ++ ys) map f = (xs map f) ++ (ys map f)

当涉及多个列表时，如何通过归纳法处理证明？

我检查了xs为Nil和ys为Nil的基本情况。 我通过归纳证明，当xs替换为x :: xs时方程成立，但是我们还需要检查ys替换为y :: ys的方程吗？

在那种情况下（不会过度破坏练习...无论如何也不会评分）您如何处理： (xs ++ (y::ys)) map f ？

这是我在类似示例中使用的方法，以证明

(xs ++ ys).reverse = ys.reverse ++ xs.reverse

证明（省略基本情况和简单的x :: xs情况）：

(xs ++ (y::ys)).reverse
= (xs ++ (List(y) ++ ys)).reverse         //y::ys = List(y) ++ ys
= ((xs ++ List(y)) ++ ys).reverse         //concat associativity
= ys.reverse ++ (xs ++ List(y)).reverse   //by induction hypothesis (proven with x::xs)
= ys.reverse ++ List(y).reverse ++ xs.reverse //by induction hypothesis
= ys.reverse ++ (y::Nil).reverse ++ xs.reverse //List(y) = y :: Nil
= ys.reverse ++ Nil.reverse ++ List(y) ++ xs.reverse //reverse definition
= (ys.reverse ++ List(y)) ++ xs.reverse //reverse on Nil (base case)
= (y :: ys).reverse ++ xs.reverse         //reverse definition

这是正确的吗 ？

Answer 1

该属性涉及多个列表，但是++仅在其左参数上递归。 这暗示您可以通过对左引数的归纳来证明。 通常，当证明某个递归函数的命题时， 您尝试做的第一件事是引入函数递归于的相同参数 。

我将为您做一个例子：

索赔 ： (xs ++ ys) map f = (xs map f) ++ (ys map f)

证明 ：通过对xs的归纳。

• 基本情况： xs = Nil

  • lhs = (Nil ++ ys) map f = ys map f

    （通过++的定义）

  • rhs = (Nil map f) ++ (ys map f) = Nil ++ ys map f = ys map f

    （按map的定义，然后按++的定义）

  • 因此lhs = rhs

• 归纳案例： xs = z :: zs

  • 假设 ： (zs ++ ys) map f = (zs map f) ++ (ys map f)
  • 目标 ： ((z :: zs) ++ ys) map f = ((z :: zs) map f) ++ (ys map f)

  • lhs = (z :: (zs ++ ys)) map f = f(z) :: ((zs ++ ys) map f) （1）

    （根据map的定义）

  • rhs = ((z :: zs) map f) ++ (ys map f) = (f(z) :: (zs map f)) ++ (ys map f)

    （根据map的定义）

  • 反过来， rhs = f(z) :: ((zs map f) ++ (ys map f)) （2）

    （通过++的定义）

  • 根据假设 （1）和（2） ，我们证明了目标 。

因此，我们证明了该主张对xs ， ys和f毫无保留。

Answer 2

正如@Phil的评论所说，首先要很好地了解++和::在列表上的方法，更好的方法是文档

我们如何证明列表程序的属性？ 答案是通过结构归纳法！ 通过结构归纳证明列表属性P（xs）的证明规则：

所有x，xs的P（无）（基本情况）：P（xs）=> P（x :: xs）（归纳步骤）

对于所有xs：P（xs）（结果）

归纳步骤中的P（xs）称为归纳假设

因为唯一重要的是xs，ys固定长度为l的正确列表，在证明xs之后，您可以证明ys，或者看到它是可交换的

因此，让我们应用归纳法和函数定义

P（xs）：（xs ++ ys）映射f =（xs映射f）++（ys映射f）

基本情况下，我们用nil代替xs

(nil ++ ys) map f [definition of ++ ] 
ys map f  on the other hand 
(xs map f) ++ (ys map p) [apply map over NIL] 
(NIL) ++ (ys map p) [definition pf ++] 
ys map p

诱导步骤

((x::xs) ++ ys) map f [definition ++]
(x:: (xs ++ ys)) map f [definition map]
f(x) :: ((xs ++ ys) map f) [induction hypothesis]
f(x) :: ((xs map f) ++ (ys map f)) [definition ++]
(f(x) :: (xs map f)) ++ (ys map f) [definition map]
(x::xs) map f ++ ys map f

QED

例如在scala工作表中的另一种情况

import scala.util.Random

// P : length ( append(as,bs) )) = length ( as ) + length (bs)

def length[T](as: List[T]): Int = as match {
    case Nil => 0
    case _::xs => 1 + length(xs)
}

def append[T](as: List[T], bs: List[T]): List[T] = as match {
  case Nil => bs
  case x :: xs => x :: append(xs, bs)
}

// base case  we substitute Nil for as in P

val a:List[Int] = Nil
val n = 10
val b:List[Int] = Seq.fill(n)(Random.nextInt).toList

length((append(a,b)))

length(a)

length(b)

导入scala.util.Random

length: length[T](val as: List[T]) => Int




append: append[T](val as: List[T],val bs: List[T]) => List[T]






a: List[Int] = List()
n: Int = 10
b: List[Int] = List(1168053950, 922397949, -1884264936, 869558369, -165728826, -1052466354, -1696038881, 246666877, 1673332480, -975585734)

res0: Int = 10

res1: Int = 0

res2: Int = 10

在这里您可以找到更多的例子