摩尔定律统制下的软件开发时代有一个非常有意思的现象：”Andy giveth, and Bill taketh away.”。不管CPU的主频有多快，我们始终有办法来利用它，而我们也陶醉在机器升级带来的程序性能提高中。

我记着我大二的时候曾经做过一个五子棋的程序，当时的算法就是预先设计一些棋型（有优先级），然后扫描棋盘，对形势进行分析，看看当前走哪部对自己最重要。当然下棋还要堵别人，这就需要互换双方的棋型再计算。如果只算一步，很可能被狡猾的对手欺骗，所以为了多想几步，还需要递归和回朔。在当时的机器上，算3步就基本上需要3秒左右的时间了。后来大学毕业收拾东西的时候找到这个程序，试了一下，发现算10步需要的时间也基本上感觉不出来了。

不知道你是否有同样的经历，我们不知不觉的一直在享受着这样的免费午餐。可是，随着摩尔定律的提前终结，免费的午餐终究要还回去。虽然硬件设计师还在努力：Hyper Threading CPU（多出一套寄存器，相当于一个逻辑CPU）使得Pipeline尽可能满负荷，使多个Thread的操作有可能并行，使得多线程程序的性能有5%-15%的提升；增加Cache容量也使得包括Single-Thread和Multi-Thread程序都能受益。也许这些还能帮助你一段时间，但问题是，我们必须做出改变，面对这个即将到来的变革，你准备好了么？

Concurrency Programming != Multi-Thread Programming。很多人都会说MultiThreading谁不会，问题是，你是为什么使用/如何使用多线程的？我从前做过一个类似AcdSee一样的图像查看/处理程序，我通常用它来处理我的数码照片。我在里面用了大量的多线程，不过主要目的是在图像处理的时候不要Block住UI，所以将CPU Intensive的计算部分用后台线程进行处理。而并没有把对图像矩阵的运算并行分开。

我觉得Concurrency Programming真正的挑战在于Programming Model的改变，在程序员的脑子里面要对自己的程序怎样并行化有很清楚的认识，更重要的是，如何去实现（包括架构、容错、实时监控等等）这种并行化，如何去调试，如何去测试。

在Google，每天有海量的数据需要在有限的时间内进行处理（其实每个互联网公司都会碰到这样的问题），每个程序员都需要进行分布式的程序开发，这其中包括如何分布、调度、监控以及容错等等。Google的MapReduce正是把分布式的业务逻辑从这些复杂的细节中抽象出来，使得没有或者很少并行开发经验的程序员也能进行并行应用程序的开发。

MapReduce中最重要的两个词就是Map（映射）和Reduce（规约）。初看Map/Reduce这两个词，熟悉Function Language的人一定感觉很熟悉。FP把这样的函数称为”higher order function”（”High order function”被成为Function Programming的利器之一哦），也就是说，这些函数是编写来被与其它函数相结合（或者说被其它函数调用的）。如果说硬要比的化，可以把它想象成C里面的CallBack函数，或者STL里面的Functor。比如你要对一个STL的容器进行查找，需要制定每两个元素相比较的Functor（Comparator），这个Comparator在遍历容器的时候就会被调用。

拿前面说过图像处理程序来举例，其实大多数的图像处理操作都是对图像矩阵进行某种运算。这里的运算通常有两种，一种是映射，一种是规约。拿两种效果来说，”老照片”效果通常是强化照片的G/B值，然后对每个象素加一些随机的偏移，这些操作在二维矩阵上的每一个元素都是独立的，是Map操作。而”雕刻”效果需要提取图像边缘，就需要元素之间的运算了，是一种Reduce操作。再举个简单的例子，一个一维矩阵（数组）[0,1,2,3,4]可以映射为[0,2,3,6,8]（乘2），也可以映射为[1,2,3,4,5]（加1）。它可以规约为0（元素求积）也可以规约为10（元素求和）。

面对复杂问题，古人教导我们要“分而治之”，英文中对应的词是”Divide and Conquer“。Map/Reduce其实就是Divide/Conquer的过程，通过把问题Divide，使这些Divide后的Map运算高度并行，再将Map后的结果Reduce（根据某一个Key），得到最终的结果。

Googler发现这是问题的核心，其它都是共性问题。因此，他们把MapReduce抽象分离出来。这样，Google的程序员可以只关心应用逻辑，关心根据哪些Key把问题进行分解，哪些操作是Map操作，哪些操作是Reduce操作。其它并行计算中的复杂问题诸如分布、工作调度、容错、机器间通信都交给Map/Reduce Framework去做，很大程度上简化了整个编程模型。

MapReduce的另一个特点是，Map和Reduce的输入和输出都是中间临时文件（MapReduce利用Google文件系统来管理和访问这些文件），而不是不同进程间或者不同机器间的其它通信方式。我觉得，这是Google一贯的风格，化繁为简，返璞归真。

接下来就放下其它，研究一下Map/Reduce操作。（其它比如容错、备份任务也有很经典的经验和实现，论文里面都有详述）

Map的定义：

Map, written by the user, takes an input pair and produces a set of intermediate key/value pairs. The MapReduce library groups together all intermediate values associated with the same intermediate key I and passes them to the Reduce function.

Reduce的定义：

The Reduce function, also written by the user, accepts an intermediate key I and a set of values for that key. It merges together these values to form a possibly smaller set of values. Typically just zero or one output value is produced per Reduce invocation. The intermediate values are supplied to the user’s reduce function via an iterator. This allows us to handle lists of values that are too large to fit in memory.

MapReduce论文中给出了这样一个例子：在一个文档集合中统计每个单词出现的次数。

Map操作的输入是每一篇文档，将输入文档中每一个单词的出现输出到中间文件中去。

map(String key, String value):
    // key: document name
    // value: document contents
    for each word w in value:
        EmitIntermediate(w, “1″);

比如我们有两篇文档，内容分别是

A － “I love programming”

B － “I am a blogger, you are also a blogger”。

B文档经过Map运算后输出的中间文件将会是：

	I,1
	am,1
	a,1
	blogger,1
	you,1
	are,1
	a,1
	blogger,1

Reduce操作的输入是单词和出现次数的序列。用上面的例子来说，就是 (”I”, [1, 1]), (”love”, [1]), (”programming”, [1]), (”am”, [1]), (”a”, [1,1]) 等。然后根据每个单词，算出总的出现次数。

reduce(String key, Iterator values):
    // key: a word
    // values: a list of counts
    int result = 0;
    for each v in values:
        result += ParseInt(v);
    Emit(AsString(result));

最后输出的最终结果就会是：(”I”, 2″), (”a”, 2″)……

实际的执行顺序是：

1. MapReduce Library将Input分成M份。这里的Input Splitter也可以是多台机器并行Split。
2. Master将M份Job分给Idle状态的M个worker来处理；
3. 对于输入中的每一个<key, value> pair 进行Map操作，将中间结果Buffer在Memory里；
4. 定期的（或者根据内存状态），将Buffer中的中间信息Dump到本地磁盘上，并且把文件信息传回给Master（Master需要把这些信息发送给Reduce worker）。这里最重要的一点是，在写磁盘的时候，需要将中间文件做Partition（比如R个）。拿上面的例子来举例，如果把所有的信息存到一个文件，Reduce worker又会变成瓶颈。我们只需要保证相同Key能出现在同一个Partition里面就可以把这个问题分解。
5. R个Reduce worker开始工作，从不同的Map worker的Partition那里拿到数据（read the buffered data from the local disks of the map workers），用key进行排序（如果内存中放不下需要用到外部排序 - external sort）。很显然，排序（或者说Group）是Reduce函数之前必须做的一步。 这里面很关键的是，每个Reduce worker会去从很多Map worker那里拿到X(0<X<R) Partition的中间结果，这样，所有属于这个Key的信息已经都在这个worker上了。
6. Reduce worker遍历中间数据，对每一个唯一Key，执行Reduce函数（参数是这个key以及相对应的一系列Value）。
7. 执行完毕后，唤醒用户程序，返回结果（最后应该有R份Output，每个Reduce Worker一个）。

可见，这里的分（Divide）体现在两步，分别是将输入分成M份，以及将Map的中间结果分成R份。将输入分开通常很简单，Map的中间结果通常用”hash(key) mod R”这个结果作为标准，保证相同的Key出现在同一个Partition里面。当然，使用者也可以指定自己的Partition Function，比如，对于Url Key，如果希望同一个Host的URL出现在同一个Partition，可以用”hash(Hostname(urlkey)) mod R”作为Partition Function。

对于上面的例子来说，每个文档中都可能会出现成千上万的 (”the”, 1)这样的中间结果，琐碎的中间文件必然导致传输上的损失。因此，MapReduce还支持用户提供Combiner Function。这个函数通常与Reduce Function有相同的实现，不同点在于Reduce函数的输出是最终结果，而Combiner函数的输出是Reduce函数的某一个输入的中间文件。

Tom White给出了Nutch[2]中另一个很直观的例子，分布式Grep。我一直觉得，Pipe中的很多操作，比如More、Grep、Cat都类似于一种Map操作，而Sort、Uniq、wc等都相当于某种Reduce操作。

加上前两天Google刚刚发布的BigTable论文，现在Google有了自己的集群 - Googel Cluster，分布式文件系统 - GFS，分布式计算环境 - MapReduce，分布式结构化存储 - BigTable，再加上Lock Service。我真的能感觉的到Google著名的免费晚餐之外的对于程序员的另一种免费的晚餐，那个由大量的commodity PC组成的large clusters。我觉得这些才真正是Google的核心价值所在。

呵呵，就像微软老兵Joel Spolsky（你应该看过他的”Joel on Software”吧？）曾经说过，对于微软来说最可怕的是[1]，微软还在苦苦追赶Google来完善Search功能的时候，Google已经在部署下一代的超级计算机了。

The very fact that Google invented MapReduce, and Microsoft didn’t, says something about why Microsoft is still playing catch up trying to get basic search features to work, while Google has moved on to the next problem: building Skynet^H^H^H^H^H^H the world’s largest massively parallel supercomputer. I don’t think Microsoft completely understands just how far behind they are on that wave.

注1：其实，微软也有自己的方案 - DryAd。问题是，大公司里，要想重新部署这样一个底层的InfraStructure，无论是技术的原因，还是政治的原因，将是如何的难。

注2：Lucene之父Doug Cutting的又一力作，Project Hadoop - 由Hadoop分布式文件系统和一个Map/Reduce的实现组成，Lucene/Nutch的成产线也够齐全的了。

from: http://xerdoc.com/blog/archives/246.html

One day, you're browsing through your code, and you notice two big blocks that look almost exactly the same. In fact, they're exactly the same, except that one block refers to "Spaghetti" and one block refers to "Chocolate Moose."

    // A trivial example:
    
    alert("I'd like some Spaghetti!");
    alert("I'd like some Chocolate Moose!");

These examples happen to be in JavaScript, but even if you don't know JavaScript, you should be able to follow along.

The repeated code looks wrong, of course, so you create a function:

    function SwedishChef( food )
    {
        alert("I'd like some " + food + "!");
    }
	
    SwedishChef("Spaghetti");
    SwedishChef("Chocolate Moose");

OK, it's a trivial example, but you can imagine a more substantial example. This is better code for many reasons, all of which you've heard a million times. Maintainability, Readability, Abstraction = Good!

Now you notice two other blocks of code which look almost the same, except that one of them keeps calling this function called BoomBoom and the other one keeps calling this function called PutInPot. Other than that, the code is pretty much the same.

    alert("get the lobster");
    PutInPot("lobster");
    PutInPot("water");

    alert("get the chicken");
    BoomBoom("chicken");
    BoomBoom("coconut");

Now you need a way to pass an argument to the function which itself is a function. This is an important capability, because it increases the chances that you'll be able to find common code that can be stashed away in a function.

    function Cook( i1, i2, f )
    {
        alert("get the " + i1);
        f(i1);
        f(i2);
    }

    Cook( "lobster", "water", PutInPot );
    Cook( "chicken", "coconut", BoomBoom );

Look! We're passing in a function as an argument.

Can your language do this?

Wait... suppose you haven't already defined the functions PutInPot or BoomBoom. Wouldn't it be nice if you could just write them inline instead of declaring them elsewhere?

    Cook( "lobster", 
          "water", 
          function(x) { alert("pot " + x); }  );
    Cook( "chicken", 
          "coconut", 
          function(x) { alert("boom " + x); } );

Jeez, that is handy. Notice that I'm creating a function there on the fly, not even bothering to name it, just picking it up by its ears and tossing it into a function.

As soon as you start thinking in terms of anonymous functions as arguments, you might notice code all over the place that, say, does something to every element of an array.

    var a = [1,2,3];
	
    for (i=0; i<a.length; i++)
    {
        a[i] = a[i] * 2;
    }
	
    for (i=0; i<a.length; i++)
    {
        alert(a[i]);
    }

Doing something to every element of an array is pretty common, and you can write a function that does it for you:

    function map(fn, a)
    {
        for (i = 0; i < a.length; i++)
        {
            a[i] = fn(a[i]);
        }
    }

Now you can rewrite the code above as:

    map( function(x){return x*2;}, a );
    map( alert, a );

Another common thing with arrays is to combine all the values of the array in some way. 

    function sum(a)
    {
        var s = 0;
        for (i = 0; i < a.length; i++)
            s += a[i];
        return s;
    }
    
    function join(a)
    {
        var s = "";
        for (i = 0; i < a.length; i++)
            s += a[i];
        return s;
    }
    
    alert(sum([1,2,3]));
    alert(join(["a","b","c"]));

sum and join look so similar, you might want to abstract out their essence into a generic function that combines elements of an array into a single value:

    function reduce(fn, a, init)
    {
        var s = init;
        for (i = 0; i < a.length; i++)
            s = fn( s, a[i] );
        return s;
    }
    
    function sum(a)
    {
        return reduce( function(a, b){ return a + b; }, 
                       a, 0 );
    }
    
    function join(a)
    {
        return reduce( function(a, b){ return a + b; }, 
                       a, "" );
    }

Many older languages simply had no way to do this kind of stuff. Other languages let you do it, but it's hard (for example, C has function pointers, but you have to declare and define the function somewhere else). Object-oriented programming languages aren't completely convinced that you should be allowed to do anything with functions.

Java required you to create a whole object with a single method called a functor if you wanted to treat a function like a first class object. Combine that with the fact that many OO languages want you to create a whole file for each class, and it gets really klunky fast. If your programming language requires you to use functors, you're not getting all the benefits of a modern programming environment. See if you can get some of your money back.

How much benefit do you really get out of writting itty bitty functions that do nothing more than iterate through an array doing something to each element?

Well, let's go back to that map function. When you need to do something to every element in an array in turn, the truth is, it probably doesn't matter what order you do them in. You can run through the array forward or backwards and get the same result, right? In fact, if you have two CPUs handy, maybe you could write some code to have each CPU do half of the elements, and suddenly map is twice as fast.

Or maybe, just hypothetically, you have hundreds of thousands of servers in several data centers around the world, and you have a really big array, containing, let's say, again, just hypothetically, the entire contents of the internet. Now you can run map on thousands of computers, each of which will attack a tiny part of the problem.

So now, for example, writing some really fast code to search the entire contents of the internet is as simple as calling the map function with a basic string searcher as an argument.

The really interesting thing I want you to notice, here, is that as soon as you think of map and reduce as functions that everybody can use, and they use them, you only have to get one supergenius to write the hard code to run map and reduce on a global massively parallel array of computers, and all the old code that used to work fine when you just ran a loop still works only it's a zillion times faster which means it can be used to tackle huge problems in an instant.

Lemme repeat that. By abstracting away the very concept of looping, you can implement looping any way you want, including implementing it in a way that scales nicely with extra hardware.

And now you understand something I wrote a while ago where I complained about CS students who are never taught anything but Java:

Without understanding functional programming, you can't invent MapReduce, the algorithm that makes Google so massively scalable. The terms Map and Reduce come from Lisp and functional programming. MapReduce is, in retrospect, obvious to anyone who remembers from their 6.001-equivalent programming class that purely functional programs have no side effects and are thus trivially parallelizable. The very fact that Google invented MapReduce, and Microsoft didn't, says something about why Microsoft is still playing catch up trying to get basic search features to work, while Google has moved on to the next problem: building Skynet^H^H^H^H^H^H the world's largest massively parallel supercomputer. I don't think Microsoft completely understands just how far behind they are on that wave.

Ok. I hope you're convinced, by now, that programming languages with first-class functions let you find more opportunities for abstraction, which means your code is smaller, tighter, more reusable, and more scalable. Lots of Google applications use MapReduce and they all benefit whenever someone optimizes it or fixes bugs.

And now I'm going to get a little bit mushy, and argue that the most productive programming environments are the ones that let you work at different levels of abstraction. Crappy old FORTRAN really didn't even let you write functions. C had function pointers, but they were ugleeeeee and not anonymous and had to be implemented somewhere else than where you were using them. Java made you use functors, which is even uglier. As Steve Yegge points out, Java is the Kingdom of Nouns.

Correction: The last time I used FORTRAN was 27 years ago. Apparently it got functions. I must have been thinking about GW-BASIC.

Let us consider a program P, taking two arguments S and D, and producing a result R:

A specialization of P with respect to S is a program P_S such that, for all input D,

Input S is called static, it is known (i.e., available) at specialization time. Input D is dynamic, it is unknown (i.e., unavailable) until run time.

Program specialization makes sense in any programming language. Consider for example the following Scheme program. (See below for more examples, in C.)

(define (append list1 list2)
   (if (null? list1)
       list2
       (cons (car list1) (append (cdr list1) list2))))

A possible specialization of append with respect to a static argument list1 = (4 2) is function append42 below.

(define (append42 list2)
   (cons 4 (cons 2 list2)))

Function append42 preserves the semantics of append, or more precisely, it has the same semantics as the trivial specialization function triv_append42, defined as

(define (triv-append42 list2)
   (append '(4 2) list2))

Depending on the context, S is called a specialization value or an invariant. In the general case, a specialization may exploit several invariants, whether input values or constants already present in the code of P.

The interest of function append42 above, as opposed to triv-append42, is that computations depending only on the static input list1 = (4 2) have already been performed. More generally, specialization impacts on speed and size of programs, thus offering applications to program optimization.

Speed

Specialization factors out computations from the specialized program. As a result, a specialized program runs faster than the original program. (Although, in some rare cases, cache effects may yield a slight slowdown.) For example, function append42 above runs faster than append (or more precisely, triv-append42) because the traversal of argument list1 as already been performed.

Size

A specialized program is sometimes smaller than the original program (e.g., when a static input corresponds to an option that dispatches on different functionalities of the program). It is sometimes bigger (e.g., when a loop or a recursive call is unfolded).

Note that all program arguments do not have the same impact on specialization. For example, specializing append with respect to list2 = (4 2) leads to the quite unexciting function below.

(define (dull-append42 list1)
   (if (null? list1)
       '(4 2)
       (cons (car list1) (dull-append42 (cdr list1)))))

Specialization is used in particular (sometimes unknowingly) to optimize critical sections of code. It is often handwritten.

Partial evaluation (PE) is the process that automates program specialization [CD93, DRT96, JGS93]. A partial evaluator (or specializer) is a program M that takes two arguments, the source of a program P and a static (known) subset of the input S, and produces a specialized program P_S:

Roughly speaking, partial evaluation can be thought of as a combination of aggressive constant folding, inlining, loop unrolling and inter-procedural constant propagation applied to all data types (including pointers, structures and arrays) instead of just scalars.

Handwritten specialization is tedious, error-prone and does not scale to large programs. Because it is automatic, specialization via partial evaluation does not have all those drawbacks; it is even predictable (see below). As a result, specialization becomes an issue in engineering software: it is possible to rapidly write generic programs, which are maintainable but slow, and automatically produce fast specialized instances. Because the programmer focuses less on optimization hacks, and more on reusability, partial evaluation greatly improve productivity and program safety.

Partial evaluation has been successfully applied as an optimizer in various domains such as operating systems and networking, computer graphics, numerical computation, circuit simulation, software architectures, compiling and compiler generation.

It has also been used for program understanding and reengineering: given various running options, partial evaluation may split large programs into smaller ones.

An on-line partial evaluator takes as arguments the source of a program P and a static subset of the input S, performs symbolic computations on available data, and directly yields the source of a specialized program P_S.

In an off-line partial evaluator, the specialization is divided into two steps. First, an program binding-time analysis propagate abstract information about static and dynamic values throughout the code. It prepares the second phase that, given actual specialization values, produce specialized code.

On-line partial evaluator are theoretically more powerful: specialization relies on actual values, not on the fact that values are known. On the other hand, off-line partial evaluator are faster because value propagation is "pre-compiled". Moreover, they are predictable in the sense that it is possible to assess the degree of specialization.

Some partial evaluators, like Tempo, can specialize programs not only at compile time (i.e., source-to-source transformation) but also run time (i.e., run-time code generation). Only off-line partial evaluation lends itself to run-time specialization.

miniprintf(char fmt[], int val[])
{
  int i = 0;
  while( *fmt != '\0' ) {
    if( *fmt != '%' )
       putchar(*fmt);
    else
      switch(*++fmt) {
        case 'd' : putint(val[i++]); break;             
        case '%' : putchar('%');     break;
        default  : prterror(*fmt);   break;
      }
    fmt++;
  }
}

Binding-time analysis (BTA) propagates the static/dynamic information throughout the program and annotates each statement and expression with a binding time. These annotations can be visualized using colors (or font effects).

/*  LEGEND:  STATICDYNAMIC
 */
miniprintf(char fmt[],int val[]){int i = 0;while( *fmt != '\0' ) {if( *fmt != '%' )putchar(*fmt);elseswitch(*++fmt) {case 'd' :putint(val[i++]);break;case '%' :putchar('%');break;default  :prterror(*fmt);break;}fmt++;}}

The blue color (bold face for black and white display) represent static constructions, i.e. values that can be computed at specialization time. The red color (standard font for black and white display) is for dynamic expressions, whose value cannot be precomputed knowing only the static arguments. Basically, everything in blue (bold) will disappear after specialization; only red (standard font) parts will remain. Visualizing of the analysis is very important for the user to assess the amount of specialization in the code.

Note that in the case of languages like C, the binding-time analysis must takes into account pointer aliases and side-effects.

miniprintf_1(int val[])
{
  putchar( '<'    );
  putint ( val[0] );
  putchar( '|'    );
  putint ( val[1] );
  putchar( '>'    );
}

/* * Some dynamic execution context setting variable 'format' */
spec_printf = rts_miniprintf(format);  // specialize
...
(*spec_printf)(val1);  // <=> miniprintf(format,val1)
(*spec_printf)(val2);  // <=> miniprintf(format,val2)

The function rts_miniprintf() is a dedicated runtime specializer. It returns a pointer to the specialized function. Several specialized versions can also be generated and used at the same time.

Various resources concerning partial evaluation, including existing specializers, PE-related events and basic references are accessible from pe_resources.php3.

[CD93]

Tutorial Notes on Partial Evaluation. C. Consel and O. Danvy. In ACM Symposium on Principles of Programming Languages, pages 493-501, 1993.

[CHL+98]

C. Consel, L. Hornof, J. Lawall, R. Marlet, G. Muller, J. Noyé, S. Thibault, and N. Volanschi. Tempo: Specializing systems applications and beyond. ACM Computing Surveys, Symposium on Partial Evaluation, 1998. To appear.

[CHN+96]

C. Consel, L. Hornof, F. Noël, J. Noyé, and E.N. Volanschi. A uniform approach for compile-time and run-time specialization. In O. Danvy, R. Glück, and P. Thiemann, editors, Partial Evaluation, International Seminar, Dagstuhl Castle, number 1110 in Lecture Notes in Computer Science, pages 54-72, February 1996.

[CN96]

C. Consel and F. Noël. A general approach for run-time specialization and its application to C. In Conference Record of the 23rd Annual ACM SIGPLAN-SIGACT Symposium on Principles Of Programming Languages, pages 145-156, St. Petersburg Beach, FL, USA, January 1996. ACM Press.

[DRT96]

Partial Evaluation. O. Danvy, R. Glück and P. Thiemann (Eds.). Lecture Notes in Computer Science, Vol. 1110.

[JGS93]

Partial evaluation and automatic program generation. N.D. Jones, C. Gomard and P. Sestoft. Prentice Hall international series in computer science, 1993.

[NHCL97]

F. Noël, L. Hornof, C. Consel, and J. Lawall. Automatic, template-based run-time specialization : Implementation and experimental study. In International Conference on Computer Languages, Chicago, IL, May 1998. IEEE Computer Society Press. Also available as IRISA report PI-1065.

值得注意的是,麦卡锡所作的发现,不仅是计算机史上划时代的大事, 而且是一种在我们这个时代编程越来越趋向的模式.我认为目前为止只有两种真正干净利落, 始终如一的编程模式:C语言模式和Lisp语言模式.此二者就象两座高地, 在它们中间是尤如沼泽的低地.随着计算机变得越来越强大,新开发的语言一直在坚定地趋向于Lisp模式. 二十年来,开发新编程语言的一个流行的秘决是,取C语言的计算模式,逐渐地往上加Lisp模式的特性,例如运行时类型和无用单元收集.

在这篇文章中我尽可能用最简单的术语来解释约翰麦卡锡所做的发现. 关键是我们不仅要学习某个人四十年前得出的有趣理论结果, 而且展示编程语言的发展方向. Lisp的不同寻常之处--也就是它优质的定义--是它能够自己来编写自己. 为了理解约翰麦卡锡所表述的这个特点,我们将追溯他的步伐,并将他的数学标记转换成能够运行的Common Lisp代码.

七个原始操作符

开始我们先定义表达式.表达式或是一个原子(atom),它是一个字母序列(如 foo),或是一个由零个或多个表达式组成的表(list), 表达式之间用空格分开, 放入一对括号中. 以下是一些表达式:

foo
()
(foo)
(foo bar)
(a b (c) d)

在算术中表达式 1 + 1 得出值2. 正确的Lisp表达式也有值. 如果表达式e得出值v,我们说e返回v. 下一步我们将定义几种表达式以及它们的返回值.

如果一个表达式是表,我们称第一个元素为操作符,其余的元素为自变量.我们将定义七个原始(从公理的意义上说)操作符: quote,atom,eq,car,cdr,cons,和 cond.

1. (quote x) 返回x.为了可读性我们把(quote x)简记 为'x.

   > (quote a)
   a
   > 'a
   a
   > (quote (a b c))
   (a b c)
   

2. (atom x)返回原子t如果x的值是一个原子或是空表,否则返回(). 在Lisp中我们按惯例用原子t表示真, 而用空表表示假.

   > (atom 'a)
   t
   > (atom '(a b c))
   ()
   > (atom '())
   t
   

   既然有了一个自变量需要求值的操作符, 我们可以看一下quote的作用. 通过引用(quote)一个表,我们避免它被求值. 一个未被引用的表作为自变量传给象 atom这样的操作符将被视为代码:

   > (atom (atom 'a))
   t
   

   反之一个被引用的表仅被视为表, 在此例中就是有两个元素的表:

   > (atom '(atom 'a))
   ()
   

   这与我们在英语中使用引号的方式一致. Cambridge(剑桥)是一个位于麻萨诸塞州有90000人口的城镇. 而``Cambridge''是一个由9个字母组成的单词.

   引用看上去可能有点奇怪因为极少有其它语言有类似的概念. 它和Lisp最与众不同的特征紧密联系:代码和数据由相同的数据结构构成, 而我们用quote操作符来区分它们.

3. (eq xy)返回t如果x和y的值是同一个原子或都是空表, 否则返回().

   > (eq 'a 'a)
   t
   > (eq 'a 'b)
   ()
   > (eq '() '())
   t
   

4. (car x)期望x的值是一个表并且返回x的第一个元素.

   > (car '(a b c))
   a
   

5. (cdr x)期望x的值是一个表并且返回x的第一个元素之后的所有元素.

   > (cdr '(a b c))
   (b c)
   

6. (cons xy)期望y的值是一个表并且返回一个新表,它的第一个元素是x的值, 后面跟着y的值的各个元素.

   > (cons 'a '(b c))
   (a b c)
   > (cons 'a (cons 'b (cons 'c '())))
   (a b c)
   > (car (cons 'a '(b c)))
   a
   > (cdr (cons 'a '(b c)))
   (b c)
   

7. (cond (...) ...(...)) 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.

   > (cond ((eq 'a 'b) 'first)
           ((atom 'a)  'second))
   second
   

   当表达式以七个原始操作符中的五个开头时,它的自变量总是要求值的.² 我们称这样 的操作符为函数.

函数的表示

((lambda (...) e) ...)

则称为函数调用.它的值计算如下.每一个表达式先求值,然后e再求值.在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值.

> ((lambda (x) (cons x '(b))) 'a)
(a b)
> ((lambda (x y) (cons x (cdr y)))
   'z
   '(a b c))
(z b c)

(f ...)

并且f的值是一个函数(lambda (...)),则以上表达式的值就是

((lambda (...) e) ...)

的值. 换句话说,参数在表达式中不但可以作为自变量也可以作为操作符使用:

> ((lambda (f) (f '(b c)))
   '(lambda (x) (cons 'a x)))
(a b c)

有另外一个函数记号使得函数能提及它本身,这样我们就能方便地定义递归函数.³ 记号

(label f (lambda (...) e))

表示一个象(lambda (...) e)那样的函数,加上这样的特性: 任何出现在e中的f将求值为此label表达式, 就好象f是此函数的参数.

假设我们要定义函数(subst x y z), 它取表达式x,原子y和表z做参数,返回一个象z那样的表, 不过z中出现的y(在任何嵌套层次上)被x代替.

> (subst 'm 'b '(a b (a b c) d))
(a m (a m c) d)

(label subst (lambda (x y z)
               (cond ((atom z)
                      (cond ((eq z y) x)
                            ('t z)))
                     ('t (cons (subst x y (car z))
                               (subst x y (cdr z)))))))

(defun f (...) e)

于是

(defun subst (x y z)
  (cond ((atom z)
         (cond ((eq z y) x)
               ('t z)))
        ('t (cons (subst x y (car z))
                  (subst x y (cdr z))))))

(cond (x y) ('t z))

等同于我们在某些语言中写的

if x then y else z

一些函数

> (cadr '((a b) (c d) e))
(c d)
> (caddr '((a b) (c d) e))
e
> (cdar '((a b) (c d) e))
(b)

> (cons 'a (cons 'b (cons 'c '())))
(a b c)
> (list 'a 'b 'c)
(a b c)

现在我们定义一些新函数. 我在函数名后面加了点,以区别函数和定义它们的原始函数,也避免与现存的common Lisp的函数冲突.

1. (null. x)测试它的自变量是否是空表.

   (defun null. (x)
     (eq x '()))
   
   > (null. 'a)
   ()
   > (null. '())
   t
   

2. (and. x y)返回t如果它的两个自变量都是t, 否则返回().

   (defun and. (x y)
     (cond (x (cond (y 't) ('t '())))
           ('t '())))
   
   > (and. (atom 'a) (eq 'a 'a))
   t
   > (and. (atom 'a) (eq 'a 'b))
   ()
   

3. (not. x)返回t如果它的自变量返回(),返回()如果它的自变量返回t.

   (defun not. (x)
     (cond (x '())
           ('t 't)))
   
   > (not. (eq 'a 'a))
   ()
   > (not. (eq 'a 'b))
   t
   

4. (append. x y)取两个表并返回它们的连结.

   (defun append. (x y)
      (cond ((null. x) y)
            ('t (cons (car x) (append. (cdr x) y)))))
   
   > (append. '(a b) '(c d))
   (a b c d)
   > (append. '() '(c d))
   (c d)
   

5. (pair. x y)取两个相同长度的表,返回一个由双元素表构成的表,双元素表是相应位置的x,y的元素对.

   (defun pair. (x y)
     (cond ((and. (null. x) (null. y)) '())
           ((and. (not. (atom x)) (not. (atom y)))
            (cons (list (car x) (car y))
                  (pair. (cdr) (cdr y))))))
   
   > (pair. '(x y z) '(a b c))
   ((x a) (y b) (z c))
   

6. (assoc. x y)取原子x和形如pair.函数所返回的表y,返回y中第一个符合如下条件的表的第二个元素:它的第一个元素是x.

   (defun assoc. (x y)
     (cond ((eq (caar y) x) (cadar y))
           ('t (assoc. x (cdr y)))))
   
   > (assoc. 'x '((x a) (y b)))
   a
   > (assoc. 'x '((x new) (x a) (y b)))
   new
   

一个惊喜

(defun eval. (e a)
  (cond 
    ((atom e) (assoc. e a))
    ((atom (car e))
     (cond 
       ((eq (car e) 'quote) (cadr e))
       ((eq (car e) 'atom)  (atom   (eval. (cadr e) a)))
       ((eq (car e) 'eq)    (eq     (eval. (cadr e) a)
                                    (eval. (caddr e) a)))
       ((eq (car e) 'car)   (car    (eval. (cadr e) a)))
       ((eq (car e) 'cdr)   (cdr    (eval. (cadr e) a)))
       ((eq (car e) 'cons)  (cons   (eval. (cadr e) a)
                                    (eval. (caddr e) a)))
       ((eq (car e) 'cond)  (evcon. (cdr e) a))
       ('t (eval. (cons (assoc. (car e) a)
                        (cdr e))
                  a))))
    ((eq (caar e) 'label)
     (eval. (cons (caddar e) (cdr e))
            (cons (list (cadar e) (car e)) a)))
    ((eq (caar e) 'lambda)
     (eval. (caddar e)
            (append. (pair. (cadar e) (evlis. (cdr  e) a))
                     a)))))

(defun evcon. (c a)
  (cond ((eval. (caar c) a)
         (eval. (cadar c) a))
        ('t (evcon. (cdr c) a))))

(defun evlis. (m a)
  (cond ((null. m) '())
        ('t (cons (eval.  (car m) a)
                  (evlis. (cdr m) a)))))

eval.有两个自变量: e是要求值的表达式, a是由一些赋给原子的值构成的表,这些值有点象函数调用中的参数. 这个形如pair.的返回值的表叫做环境. 正是为了构造和搜索这种表我们才写了pair.和assoc..

eval.的骨架是一个有四个子句的cond表达式. 如何对表达式求值取决于它的类型. 第一个子句处理原子. 如果e是原子, 我们在环境中寻找它的值:

> (eval. 'x '((x a) (y b)))
a

第二个子句是另一个cond, 它处理形如(a ...)的表达式, 其中a是原子. 这包括所有的原始操作符, 每个对应一条子句.

> (eval. '(eq 'a 'a) '())
t
> (eval. '(cons x '(b c))
         '((x a) (y b)))
(a b c)

最后两个子句更复杂些. 为了求cond表达式的值我们调用了一个叫 evcon.的辅助函数. 它递归地对cond子句进行求值,寻找第一个元素返回t的子句. 如果找到了这样的子句, 它返回此子句的第二个元素.

> (eval. '(cond ((atom x) 'atom)
                ('t 'list))
         '((x '(a b))))
list

第二个子句的最后部分处理函数调用. 它把原子替换为它的值(应该是lambda 或label表达式)然后对所得结果表达式求值. 于是

(eval. '(f '(b c))
       '((f (lambda (x) (cons 'a x)))))

(eval. '((lambda (x) (cons 'a x)) '(b c))
       '((f (lambda (x) (cons 'a x)))))

eval.的最后cond两个子句处理第一个元素是lambda或label的函数调用.为了对label 表达式求值, 先把函数名和函数本身压入环境, 然后调用eval.对一个内部有 lambda的表达式求值. 即:

(eval. '((label firstatom (lambda (x)
                            (cond ((atom x) x)
                                  ('t (firstatom (car x))))))
         y)
       '((y ((a b) (c d)))))

(eval. '((lambda (x)
           (cond ((atom x) x)
                 ('t (firstatom (car x)))))
         y)
        '((firstatom
           (label firstatom (lambda (x)
                            (cond ((atom x) x)
                                  ('t (firstatom (car x)))))))
          (y ((a b) (c d)))))

最后,对形如((lambda (...) e) ...)的表达式求值,先调用evlis.来求得自变量(...)对应的值(...),把()...()添加到环境里, 然后对e求值. 于是

(eval. '((lambda (x y) (cons x (cdr y)))
         'a
         '(b c d))
       '())

(eval. '(cons x (cdr y))
       '((x a) (y (b c d))))

后果

既然理解了eval是如何工作的, 让我们回过头考虑一下这意味着什么. 我们在这儿得到了一个非常优美的计算模型. 仅用quote,atom,eq,car,cdr,cons,和cond, 我们定义了函数eval.,它事实上实现了我们的语言,用它可以定义任何我们想要的额外的函数.

当然早已有了各种计算模型--最著名的是图灵机. 但是图灵机程序难以读懂. 如果你要一种描述算法的语言, 你可能需要更抽象的, 而这就是约翰麦卡锡定义 Lisp的目标之一.

约翰麦卡锡于1960年定义的语言还缺不少东西. 它没有副作用, 没有连续执行 (它得和副作用在一起才有用), 没有实际可用的数,⁴ 没有动态可视域. 但这些限制可以令人惊讶地用极少的额外代码来补救. Steele和Sussman在一篇叫做``解释器的艺术''的著名论文中描述了如何做到这点.⁵

如果你理解了约翰麦卡锡的eval, 那你就不仅仅是理解了程序语言历史中的一个阶段. 这些思想至今仍是Lisp的语义核心. 所以从某种意义上, 学习约翰麦卡锡的原著向我们展示了Lisp究竟是什么. 与其说Lisp是麦卡锡的设计,不如说是他的发现. 它不是生来就是一门用于人工智能, 快速原型开发或同等层次任务的语言. 它是你试图公理化计算的结果(之一).

随着时间的推移, 中级语言, 即被中间层程序员使用的语言, 正一致地向Lisp靠近. 因此通过理解eval你正在明白将来的主流计算模式会是什么样.

注释

在约翰麦卡锡的论文中,假用f来表示, 而不是空表. 我用空表表示假以使例子能在Common Lisp中运行. (fixme)

我略过了构造dotted pairs, 因为你不需要它来理解eval. 我也没有提apply, 虽然是apply(它的早期形式, 主要作用是引用自变量), 被约翰麦卡锡在1960年称为普遍函数, eval只是不过是被apply调用的子程序来完成所有的工作.

我定义了list和cxr等作为简记法因为麦卡锡就是这么做的. 实际上 cxr等可以被定义为普通的函数. List也可以这样, 如果我们修改eval, 这很容易做到, 让函数可以接受任意数目的自变量.

麦卡锡的论文中只有五个原始操作符. 他使用了cond和quote,但可能把它们作为他的元语言的一部分. 同样他也没有定义逻辑操作符and和not, 这不是个问题, 因为它们可以被定义成合适的函数.

在eval.的定义中我们调用了其它函数如pair.和assoc.,但任何我们用原始操作符定义的函数调用都可以用eval.来代替. 即

(assoc. (car e) a)

(eval. '((label assoc.
                (lambda (x y)
                  (cond ((eq (caar y) x) (cadar y))
                        ('t (assoc. x (cdr y))))))
         (car e)
         a)
        (cons (list 'e e) (cons (list 'a a) a)))

麦卡锡的eval有一个错误. 第16行是(相当于)(evlis. (cdr e) a)而不是(cdr e), 这使得自变量在一个有名函数的调用中被求值两次. 这显示当论文发表的时候, eval的这种描述还没有用IBM 704机器语言实现. 它还证明了如果不去运行程序, 要保证不管多短的程序的正确性是多么困难.

我还在麦卡锡的论文中碰到一个问题. 在定义了eval之后, 他继续给出了一些更高级的函数--接受其它函数作为自变量的函数. 他定义了maplist:

(label maplist
       (lambda (x f)
         (cond ((null x) '())
               ('t (cons (f x) (maplist (cdr x) f))))))

这是关于动态可视域危险性的雄辩证据, 即使是最早的更高级函数的例子也因为它而出错. 可能麦卡锡在1960年还没有充分意识到动态可视域的含意. 动态可视域令人惊异地在Lisp实现中存在了相当长的时间--直到Sussman和Steele于 1975年开发了Scheme. 词法可视域没使eval的定义复杂多少, 却使编译器更难写了.

About this document ...

This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.48)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html-split=0 roots_of_lisp.tex

The translation was initiated by Dai Yuwen on 2003-10-24

Footnotes

... 欧几里德对几何的贡献.¹

``Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part1.'' Communication of the ACM 3:4, April 1960, pp. 184-195.

...当表达式以七个原始操作符中的五个开头时,它的自变量总是要求值的.²

以另外两个操作符quote和cond开头的表达式以不同的方式求值. 当 quote表达式求值时, 它的自变量不被求值,而是作为整个表达式的值返回. 在 一个正确的cond表达式中, 只有L形路径上的子表达式会被求值.

... 数.³

逻辑上我们不需要为了这定义一个新的记号. 在现有的记号中用 一个叫做Y组合器的函数上的函数, 我们可以定义递归函数. 可能麦卡锡在写 这篇论文的时候还不知道Y组合器; 无论如何, label可读性更强.

... 没有实际可用的数,⁴

在麦卡锡的1960 年的Lisp中, 做算术是可能的, 比如用一个有n个原子的表表示数n.

... 的艺术''的著名论文中描述了如何做到这点.⁵

Guy Lewis Steele, Jr. and Gerald Jay Sussman, ``The Art of the Interpreter, or the Modularity Complex(Parts Zero,One,and Two),'' MIT AL Lab Memo 453, May 1978.

... 对它的引用被maplist中的参数x所捕获.⁶

当代的Lisp程序 员在这儿会用mapcar代替maplist. 这个例子解开了一个谜团: maplist为什 么会在Common Lisp中. 它是最早的映射函数, mapcar是后来增加的.

from: http://daiyuwen.freeshell.org/gb/rol/roots_of_lisp.html

算法是计算机科学领域最重要的基石之一，但却受到了国内一些程序员的冷落。许多学生看到一些公司在招聘时要求的编程语言五花八门就产生了一种误解，认为学计算机就是学各种编程语言，或者认为，学习最新的语言、技术、标准就是最好的铺路方法。其实大家都被这些公司误导了。编程语言虽然该学，但是学习计算机算法和理论更重要，因为计算机算法和理论更重要，因为计算机语言和开发平台日新月异，但万变不离其宗的是那些算法和理论，例如数据结构、算法、编译原理、计算机体系结构、关系型数据库原理等等。在“开复学生网”上，有位同学生动地把这些基础课程比拟为“内功”，把新的语言、技术、标准比拟为“外功”。整天赶时髦的人最后只懂得招式，没有功力，是不可能成为高手的。

算法与我

当我在1980年转入计算机科学系时，还没有多少人的专业方向是计算机科学。有许多其他系的人嘲笑我们说：“知道为什么只有你们系要加一个‘科学 ’，而没有‘物理科学系’或‘化学科学系’吗？因为人家是真的科学，不需要画蛇添足，而你们自己心虚，生怕不‘科学’，才这样欲盖弥彰。”其实，这点他们彻底弄错了。真正学懂计算机的人（不只是“编程匠”）都对数学有相当的造诣，既能用科学家的严谨思维来求证，也能用工程师的务实手段来解决问题——而这种思维和手段的最佳演绎就是“算法”。

记得我读博时写的Othello对弈软件获得了世界冠军。当时，得第二名的人认为我是靠侥幸才打赢他，不服气地问我的程序平均每秒能搜索多少步棋，当他发现我的软件在搜索效率上比他快60多倍时，才彻底服输。为什么在同样的机器上，我可以多做60倍的工作呢？这是因为我用了一个最新的算法，能够把一个指数函数转换成四个近似的表，只要用常数时间就可得到近似的答案。在这个例子中，是否用对算法才是能否赢得世界冠军的关键。

还记得1988年贝尔实验室副总裁亲自来访问我的学校，目的就是为了想了解为什么他们的语音识别系统比我开发的慢几十倍，而且，在扩大至大词汇系统后，速度差异更有几百倍之多。他们虽然买了几台超级计算机，勉强让系统跑了起来，但这么贵的计算资源让他们的产品部门很反感，因为“昂贵”的技术是没有应用前景的。在与他们探讨的过程中，我惊讶地发现一个O(n*m)的动态规划(dynamic programming)居然被他们做成了O (n*n*m)。更惊讶的是，他们还为此发表了不少文章，甚至为自己的算法起了一个很特别的名字，并将算法提名到一个科学会议里，希望能得到大奖。当时，贝尔实验室的研究员当然绝顶聪明，但他们全都是学数学、物理或电机出身，从未学过计算机科学或算法，才犯了这么基本的错误。我想那些人以后再也不会嘲笑学计算机科学的人了吧！

网络时代的算法

有人也许会说：“今天计算机这么快，算法还重要吗？”其实永远不会有太快的计算机，因为我们总会想出新的应用。虽然在摩尔定律的作用下，计算机的计算能力每年都在飞快增长，价格也在不断下降。可我们不要忘记，需要处理的信息量更是呈指数级的增长。现在每人每天都会创造出大量数据（照片，视频，语音，文本等等）。日益先进的纪录和存储手段使我们每个人的信息量都在爆炸式的增长。互联网的信息流量和日志容量也在飞快增长。在科学研究方面，随着研究手段的进步，数据量更是达到了前所未有的程度。无论是三维图形、海量数据处理、机器学习、语音识别，都需要极大的计算量。在网络时代，越来越多的挑战需要靠卓越的算法来解决。

再举另一个网络时代的例子。在互联网和手机搜索，如果要找附近的咖啡店，那么搜索引擎该怎么处理这个请求呢？最简单的办法就是把整个城市的咖啡馆都找出来，然后计算出它们的所在位置与你之间的距离，再进行排序，然后返回最近的结果。但该如何计算距离呢？图论里有不少算法可以解决这个问题。

这么做也许是最直观的，但绝对不是最迅速的。如果一个城市只有为数不多的咖啡馆，那么这么做应该没什么问题，反正计算量不大。但如果一个城市里有很多咖啡馆，又有很多用户都需要类似的搜索，那么服务器所承受的压力就大多了。在这种情况下，我们该怎样优化算法呢？

首先，我们可以把整个城市的咖啡馆做一次“预处理”。比如，把一个城市分成若干个“格子(grid)”，然后根据用户所在的位置把他放到某一个格子里，只对格子里的咖啡馆进行距离排序。

问题又来了，如果格子大小一样，那么绝大多数结果都可能出现在市中心的一个格子里，而郊区的格子里只有极少的结果。在这种情况下，我们应该把市中心多分出几个格子。更进一步，格子应该是一个“树结构”，最顶层是一个大格——整个城市，然后逐层下降，格子越来越小，这样有利于用户进行精确搜索——如果在最底层的格子里搜索结果不多，用户可以逐级上升，放大搜索范围。

上述算法对咖啡馆的例子很实用，但是它具有通用性吗？答案是否定的。把咖啡馆抽象一下，它是一个“点”，如果要搜索一个“面”该怎么办呢？比如，用户想去一个水库玩，而一个水库有好几个入口，那么哪一个离用户最近呢？这个时候，上述“树结构”就要改成“r-tree”，因为树中间的每一个节点都是一个范围，一个有边界的范围（参考:http://www.cs.umd.edu/~hjs/rtrees/index.html）。

通过这个小例子，我们看到，应用程序的要求千变万化，很多时候需要把一个复杂的问题分解成若干简单的小问题，然后再选用合适的算法和数据结构。

并行算法：Google的核心优势

上面的例子在Google里就要算是小case了！每天Google的网站要处理十亿个以上的搜索，GMail要储存几千万用户的2G邮箱， Google Earth要让数十万用户同时在整个地球上遨游，并将合适的图片经过互联网提交给每个用户。如果没有好的算法，这些应用都无法成为现实。

在这些的应用中，哪怕是最基本的问题都会给传统的计算带来很大的挑战。例如，每天都有十亿以上的用户访问Google的网站，使用Google的服务，也产生很多很多的日志(Log)。因为Log每份每秒都在飞速增加，我们必须有聪明的办法来进行处理。我曾经在面试中问过关于如何对Log进行一些分析处理的问题，有很多面试者的回答虽然在逻辑上正确，但是实际应用中是几乎不可行的。按照它们的算法，即便用上几万台机器，我们的处理速度都根不上数据产生的速度。

那么Google是如何解决这些问题的？

首先，在网络时代，就算有最好的算法，也要能在并行计算的环境下执行。在Google的数据中心，我们使用的是超大的并行计算机。但传统的并行算法运行时，效率会在增加机器数量后迅速降低，也就是说，十台机器如果有五倍的效果，增加到一千台时也许就只有几十倍的效果。这种事半功倍的代价是没有哪家公司可以负担得起的。而且，在许多并行算法中，只要一个结点犯错误，所有计算都会前功尽弃。

那么Google是如何开发出既有效率又能容错的并行计算的呢？

Google最资深的计算机科学家Jeff Dean认识到，Google所需的绝大部分数据处理都可以归结为一个简单的并行算法：Map and Reduce（http://labs.google.com/papers/mapreduce.html）。这个算法能够在很多种计算中达到相当高的效率，而且是可扩展的（也就是说，一千台机器就算不能达到一千倍的效果，至少也可以达到几百倍的效果）。 Map and Reduce的另外一大特色是它可以利用大批廉价的机器组成功能强大的server farm。最后，它的容错性能异常出色，就算一个 server farm宕掉一半，整个fram依然能够运行。正是因为这个天才的认识，才有了Map and Reduce算法。借助该算法， Google几乎能无限地增加计算量，与日新月异的互联网应用一同成长。

算法并不局限于计算机和网络

举一个计算机领域外的例子：在高能物理研究方面，很多实验每秒钟都能几个TB的数据量。但因为处理能力和存储能力的不足，科学家不得不把绝大部分未经处理的数据丢弃掉。可大家要知道，新元素的信息很有可能就藏在我们来不及处理的数据里面。同样的，在其他任何领域里，算法可以改变人类的生活。例如人类基因的研究，就可能因为算法而发明新的医疗方式。在国家安全领域，有效的算法可能避免下一个911的发生。在气象方面，算法可以更好地预测未来天灾的发生，以拯救生命。

所以，如果你把计算机的发展放到应用和数据飞速增长的大环境下，你一定会发现；算法的重要性不是在日益减小，而是在日益加强。

from: http://www.yuanma.org/data/2006/0824/article_1397.htm

密码学是理论计算机的一个很大的方向。之前准备先写密码学概论再提在hash函数破解上做出重大贡献的王小云教授的工作，不过前两天王小云获得求是杰出科学家奖以及100万奖金，在媒体上又掀起了一轮宣传狂潮，但是有些报道极端弱智，错误百出，所以我趁机纠正一下，并介绍密码学的一个组成部分——hash函数，以及王小云在这上面的工作。

王小云的主要工作是关于hash函数的破解工作。她在2005一个密码学会议上宣布破解了SHA-1，震惊了全世界。所以要介绍和理解她的工作，先看一下hash函数具体是怎么回事。

简单的说，hash函数就是把任意长的输入字符串变化成固定长的输出字符串的一种函数。通俗得说，hash函数用来生成信息的摘要。输出字符串的长度称为hash函数的位数。

目前应用最为广泛的hash函数是SHA-1和MD5，大多是128位和更长。

hash函数在现实生活中应用十分广泛。很多下载网站都提供下载文件的MD5码校验，可以用来判别文件是否完整。另外，比如在WordPress的数据库，所有密码都是保存的MD5码，这样即使数据库的管理员也无法知道用户的原始密码，避免隐私泄露（很多人在不同地方都是用的同一个密码）。

如果两个输入串的hash函数的值一样，则称这两个串是一个碰撞(Collision)。既然是把任意长度的字符串变成固定长度的字符串，所以，必有一个输出串对应无穷多个输入串，碰撞是必然存在的。

一个“优良”的hash函数 f 应当满足以下三个条件：

• 任意y，找x，使得f(x)=y，非常困难。
• 给定x1，找x2，使得f(x1)=f(x2)，非常困难。
• 找x1，x2，使得f(x1)=f(x2)，非常困难。

上面的“非常困难”的意思是除了枚举外不可能有别的更快的方法。比如第3条，根据生日定理，要想找到这样的x1，x2，理论上需要大约2^(n/2)的枚举次数。

几乎所有的hash函数的破解，都是指的破坏上面的第三条性质，即找到一个碰撞（前两条都能被破坏的hash函数也太弱了点，早就被人抛弃了）。在密码学上还有一个概念是理论破解，指的是提出一个算法，使得可以用低于理论值得枚举次数找到碰撞。

王小云的主要工作是给出了MD5，SHA-0的碰撞，以及SHA-1的理论破解，她证明了160位SHA-1，只需要大约2^69次计算就能找出来，而理论值是2^80次。她的寻找MD5碰撞的方法是极端高效的。传说王小云当时在会议上把碰撞写出来，结果被下面的人验证发现不对，原来她把MD5算法的一个步骤弄错了。但是她立马联系她的当时留在中国的学生，修正算法，并找到一个新的碰撞。这一个是对的。

看到这里，那些认为中国国安局应该将这些结果封存作为秘密武器甚至幻想用这些成果来袭击美国之徒可以停住你们的YY了。这种形式上的破解，在大多数情况下没有实际性的作用。更别提MD5早就被美国人抛弃了。

但是，说这种破解一点实际意义都没有，那就侮辱了广大密码学家的智商，密码学家不会无缘无故的弄出碰撞这么一个概念来。下面简单的介绍一下在特定情况下，怎么利用给定的碰撞来做坏事(翻译自Attacking Hash Functions)：

Caesar给实习生Alice叫写了一封推荐信(letter)。同一天，Alice叫Caesar在推荐信上数字签名，并提供了一份推荐信的电子板。Caesar打开文件，发现和原件一模一样。所以他在文件上签了名。

几个月后，Caesar发现他的秘密文件被非法察看。这到底是怎么回事呢？

a25f7f0b 29ee0b39 68c86073 8533a4b9

事实上，Alice要求Caesar签名的文件letter已经被Alice做了手脚，准确地说，Alice还准备了另外一个文件order，它们的MD5码完全一致。而Caesar的数字签名还依赖于MD5算法，所以Alice用order文件替换Letter文件之后，Caesar的数字签名依然有效。那封order给Alice提供了察看秘密文件的权限。

具体的实现方法可见Hash Functions and the Blind Passenger Attack。我在这里简单的解释一下(只是大致思路，具体实现方式，需要对文件结构信息有所了解)：

letter文件的内容是：

if(x1==x1) show "letter" else show "order"

order文件的内容是：

if(x2==x1) show "letter" else show "order"

其中字符串"letter"和"order"代表两封信实际显示的内容。x1，x2是一个MD5的碰撞。

上面的方法，只供参考和学术用途，实际使用所引起的后果概不负责。

参考：

• Attacking Hash Functions by Poisoned Messages "The Story of Alice and her Boss"
• Hash function, wikipedia
• SHA, wikipedia
• Interview with Yiqun Lisa Yin concerning the attack on SHA-1

PS：我跟王小云老师的接触很少，上过俩次她的讨论班而已，亦感觉到王小云老师的严谨和耐心。在去年一个Turing奖获得者的演讲上，王小云提问的时候竟口而出“I ask who”的中式英语，在引起哄笑的同时，我也极端佩服她的勇气。也许只有这样才能做出非常好的工作吧。

PS2: wikipedia在国内可以通过free_door浏览。

http://zhiqiang.org/blog/446.html
参阅: 理论计算机, MD5, SHA-1, hash函数, 王小云, 密码学.

from: http://zhiqiang.org/blog/446.html

      上面的计算进行迭代，直到 óⁿ 和 ó^n-1之间的差别小于一个阈值，如果计算没有聚合，我们就在迭代超过一定次数后停止。上图3的第三副图，就是5次迭代后的结果。表3时一些计算方法，后面的实验表明，C比较好。A叫做 sparce，B叫做 excepted，C叫做verbose


过滤

      迭代出的结果是一种[多匹配]，可能包含有用的匹配子集。
      三个步骤：
            1。用程序定义的[限制条件]进行过滤。
            2。用双向图中的匹配上下文技术进行过滤
            3。比较各种技术的有效性（满足用户需求的能力）
      限制：主要有两种，一个是[类型]限制，比如只考虑[列]的匹配（匹配双方都是列）。第二个是 cardinality 限制，即模式S1中的所有元素都要在S2中有一个映射。

stable marriage问题：n女和n男配对，不存在这样的两对 (x; y)和(x0; y0)，其中x喜欢 y0 胜过 y，而且 y0 喜欢 x 胜过 x0。具有stable marriage的匹配结果的total satisfaction可能会比不具有stable marriage的匹配结果还低！

匹配质量的评估

   基本的评估思想，就是  用户对匹配结果做的修改越少，匹配质量就越高（修改结果包括去掉错误的pair，加上正确的pair）
  n是找到的匹配数，m是理想的匹配数，c是用户作出修正的数目。

from: http://www.cnblogs.com/anf/archive/2006/08/15/477700.html

For example, we may have the results of measurements taken by experts on some widgets. For each widget we know what is the value for each measurement and what was decided, if to pass, scrap, or repair it. That is, we have a record with as non categorical attributes the measurements, and as categorical attribute the disposition for the widget.

Here is a more detailed example. We are dealing with records reporting on weather conditions for playing golf. The categorical attribute specifies whether or not to Play. The non-categorical attributes are:

	ATTRIBUTE   |	POSSIBLE VALUES
	============+=======================
	outlook	    | sunny, overcast, rain
	------------+-----------------------
	temperature | continuous
	------------+-----------------------
	humidity    | continuous
	------------+-----------------------
	windy       | true, false
	============+=======================

and the training data is:

	OUTLOOK | TEMPERATURE | HUMIDITY | WINDY | PLAY
	=====================================================
	sunny   |      85     |    85    | false | Don't Play
	sunny   |      80     |    90    | true  | Don't Play
	overcast|      83     |    78    | false | Play
	rain    |      70     |    96    | false | Play
	rain    |      68     |    80    | false | Play
	rain    |      65     |    70    | true  | Don't Play
	overcast|      64     |    65    | true  | Play
	sunny   |      72     |    95    | false | Don't Play
	sunny   |      69     |    70    | false | Play
	rain    |      75     |    80    | false | Play
	sunny   |      75     |    70    | true  | Play
	overcast|      72     |    90    | true  | Play
	overcast|      81     |    75    | false | Play
	rain    |      71     |    80    | true  | Don't Play

A simpler example from the stock market involving only discrete ranges has Profit as categorical attribute, with values {up, down}. Its non categorical attributes are:

	ATTRIBUTE   |	POSSIBLE VALUES
	============+=======================
	age	    | old, midlife, new
	------------+-----------------------
	competition | no, yes
	------------+-----------------------
	type        | software, hardware
	------------+-----------------------

   and the training data is:

	AGE	| COMPETITION | TYPE	| PROFIT
	=========================================
	old	| yes	      | swr	| down
	--------+-------------+---------+--------
	old	| no	      | swr 	| down
	--------+-------------+---------+--------
	old	| no	      | hwr	| down
	--------+-------------+---------+--------
	mid	| yes	      | swr	| down
	--------+-------------+---------+--------
	mid	| yes	      | hwr	| down
	--------+-------------+---------+--------
	mid	| no	      | hwr	| up
	--------+-------------+---------+--------
	mid	| no	      | swr	| up
	--------+-------------+---------+--------
	new	| yes	      | swr	| up
	--------+-------------+---------+--------
	new	| no	      | hwr	| up
	--------+-------------+---------+--------
	new	| no	      | swr	| up
	--------+-------------+---------+--------
	

The basic ideas behind ID3 are that:

• In the decision tree each node corresponds to a non-categorical attribute and each arc to a possible value of that attribute. A leaf of the tree specifies the expected value of the categorical attribute for the records described by the path from the root to that leaf. [This defines what is a Decision Tree.]

• In the decision tree at each node should be associated the non-categorical attribute which is most informative among the attributes not yet considered in the path from the root. [This establishes what is a "Good" decision tree.]

• Entropy is used to measure how informative is a node. [This defines what we mean by "Good". By the way, this notion was introduced by Claude Shannon in Information Theory.]

Definitions

In general, if we are given a probability distribution P = (p1, p2, .., pn) then the Information conveyed by this distribution, also called the Entropy of P, is:

	I(P) = -(p1*log(p1) + p2*log(p2) + .. + pn*log(pn))

If a set T of records is partitioned into disjoint exhaustive classes C1, C2, .., Ck on the basis of the value of the categorical attribute, then the information needed to identify the class of an element of T is Info(T) = I(P), where P is the probability distribution of the partition (C1, C2, .., Ck):

	P = (|C1|/|T|, |C2|/|T|, ..., |Ck|/|T|)

In our golfing example, we have Info(T) = I(9/14, 5/14) = 0.94,
and in our stock market example we have Info(T) = I(5/10,5/10) = 1.0.

If we first partition T on the basis of the value of a non-categorical attribute X into sets T1, T2, .., Tn then the information needed to identify the class of an element of T becomes the weighted average of the information needed to identify the class of an element of Ti, i.e. the weighted average of Info(Ti):

					      |Ti|
	Info(X,T) = Sum for i from 1 to n of  ---- * Info(Ti)
					      |T|

In the case of our golfing example, for the attribute Outlook we have

	Info(Outlook,T) = 5/14*I(2/5,3/5) + 4/14*I(4/4,0) + 5/14*I(3/5,2/5)
			= 0.694

Consider the quantity Gain(X,T) defined as

	Gain(X,T) = Info(T) - Info(X,T)

This represents the difference between the information needed to identify an element of T and the information needed to identify an element of T after the value of attribute X has been obtained, that is, this is the gain in information due to attribute X.

In our golfing example, for the Outlook attribute the gain is:

	Gain(Outlook,T) = Info(T) - Info(Outlook,T) = 0.94 - 0.694 = 0.246.

If we instead consider the attribute Windy, we find that Info(Windy,T) is 0.892 and Gain(Windy,T) is 0.048. Thus Outlook offers a greater informational gain than Windy.

We can use this notion of gain to rank attributes and to build decision trees where at each node is located the attribute with greatest gain among the attributes not yet considered in the path from the root.

The intent of this ordering are twofold:

• To create small decision trees so that records can be identified after only a few questions.

• To match a hoped for minimality of the process represented by the records being considered(Occam's Razor).

The ID3 Algorithm

   function ID3 (R: a set of non-categorical attributes,
		 C: the categorical attribute,
		 S: a training set) returns a decision tree;
   begin
	If S is empty, return a single node with value Failure;
	If S consists of records all with the same value for 
	   the categorical attribute, 
	   return a single node with that value;
	If R is empty, then return a single node with as value
	   the most frequent of the values of the categorical attribute
	   that are found in records of S; [note that then there
	   will be errors, that is, records that will be improperly
	   classified];
	Let D be the attribute with largest Gain(D,S) 
	   among attributes in R;
	Let {dj| j=1,2, .., m} be the values of attribute D;
	Let {Sj| j=1,2, .., m} be the subsets of S consisting 
	   respectively of records with value dj for attribute D;
	Return a tree with root labeled D and arcs labeled 
	   d1, d2, .., dm going respectively to the trees 

	     ID3(R-{D}, C, S1), ID3(R-{D}, C, S2), .., ID3(R-{D}, C, Sm);
   end ID3;

In the Golfing example we obtain the following decision tree:

			Outlook
		       / |     \
		      /  |      \
            overcast /   |sunny  \rain
                    /    |        \
	         Play   Humidity   Windy
		       /   |         |  \
                      /    |         |   \
		<=75 /  >75|     true|    \false
		    /      |         |     \
                 Play   Don'tPlay Don'tPlay Play


   In the stock market case the decision tree is:


			 Age
		       / |    \
		      /  |     \
		  new/   |mid   \old
		    /    |       \
		  Up  Competition Down
                       /      \
		      /        \
		   no/          \yes
		    /            \
		  Up             Down

Here is the decision tree, just as produced by c4.5, for the voting example introduced earlier.

Using Gain Ratios

			 Gain(D,T)
	GainRatio(D,T) = ----------
			 SplitInfo(D,T)

   where SplitInfo(D,T) is the information due to the split of T on the basis
   of the value of the categorical attribute D. Thus SplitInfo(D,T) is

		 I(|T1|/|T|, |T2|/|T|, .., |Tm|/|T|)

   where {T1, T2, .. Tm} is the partition of T induced by the value of D.

   In the case of our golfing example SplitInfo(Outlook,T) is 

	-5/14*log(5/14) - 4/14*log(4/14) - 5/14*log(5/14) = 1.577

   thus the GainRatio of Outlook is 0.246/1.577 = 0.156. And 
   SplitInfo(Windy,T) is 

	-6/14*log(6/14) - 8/14*log(8/14) = 6/14*0.1.222 + 8/14*0.807 
					 = 0.985

   thus the GainRatio of Windy is 0.048/0.985 = 0.049

You can run PAIL to see how ID3 generates the decision tree [you need to have an X-server and to allow access (xhost) from yoda.cis.temple.edu].

C4.5 Extensions

In building a decision tree we can deal with training sets that have records with unknown attribute values by evaluating the gain, or the gain ratio, for an attribute by considering only the records where that attribute is defined.

In using a decision tree, we can classify records that have unknown attribute values by estimating the probability of the various possible results. In our golfing example, if we are given a new record for which the outlook is sunny and the humidity is unknown, we proceed as follows:

   We move from the Outlook root node to the Humidity node following
   the arc labeled 'sunny'. At that point since we do not know
   the value of Humidity we observe that if the humidity is at most 75
   there are two records where one plays, and if the humidity is over
   75 there are three records where one does not play. Thus one
   can give as answer for the record the probabilities
   (0.4, 0.6) to play or not to play.

We can deal with the case of attributes with continuous ranges as follows. Say that attribute Ci has a continuous range. We examine the values for this attribute in the training set. Say they are, in increasing order, A1, A2, .., Am. Then for each value Aj, j=1,2,..m, we partition the records into those that have Ci values up to and including Aj, and those that have values greater than Aj. For each of these partitions we compute the gain, or gain ratio, and choose the partition that maximizes the gain.
In our Golfing example, for humidity, if T is the training set, we determine the information for each partition and find the best partition at 75. Then the range for this attribute becomes {<=75, >75}. Notice that this method involves a substantial number of computations.

Pruning Decision Trees and Deriving Rule Sets

Pruning of the decision tree is done by replacing a whole subtree by a leaf node. The replacement takes place if a decision rule establishes that the expected error rate in the subtree is greater than in the single leaf. For example, if the simple decision tree

			Color
		       /     \
		   red/       \blue
		     /         \
		  Success     Failure

is obtained with one training red success record and two training blue Failures, and then in the Test set we find three red failures and one blue success, we might consider replacing this subtree by a single Failure node. After replacement we will have only two errors instead of five failures.

Winston shows how to use Fisher's exact test to determine if the category attribute is truly dependent on a non-categorical attribute. If it is not, then the non-categorical attribute need not appear in the current path of the decision tree.

Quinlan and Breiman suggest more sophisticated pruning heuristics.

It is easy to derive a rule set from a decision tree: write a rule for each path in the decision tree from the root to a leaf. In that rule the left-hand side is easily built from the label of the nodes and the labels of the arcs.

The resulting rules set can be simplified:

Let LHS be the left hand side of a rule. Let LHS' be obtained from LHS by eliminating some of its conditions. We can certainly replace LHS by LHS' in this rule if the subsets of the training set that satisfy respectively LHS and LHS' are equal.

A rule may be eliminated by using metaconditions such as "if no other rule applies".

You can run the C45 program here [you need to have an X-server and to allow access (xhost) from yoda.cis.temple.edu].

The software for C4.5 can be obtained with Quinlan's book. A wide variety of training and test data is available, some provided by Quinlan, some at specialized sites such as the University of California at Irvine.

Student projects may involve the implementation of these algorithms. More interesting is for students to collect or find a significant data set, partition it into training and test sets, determine a decision tree, simplify it, determine the corresponding rule set, and simplify the rule set.

The study of methods to evaluate the error performance of a decision tree is probably too advanced for most undergraduate courses.

References

   Breiman,Friedman,Olshen,Stone: Classification and Decision Trees
	Wadsworth, 1984

   A decision science perspective on decision trees.

   Quinlan,J.R.: C4.5: Programs for Machine Learning
	Morgan Kauffman, 1993

   Quinlan is a very readable, thorough book, with actual usable programs 
   that are available on the internet. Also available are a number of 
   interesting data sets.

   Quinlan,J.R.: Simplifying decision trees
	International Journal of Man-Machine Studies, 27, 221-234, 1987

   Winston,P.H.: Artificial Intelligence, Third Edition
	Addison-Wesley, 1992

   Excellent introduction to ID3 and its use in building decision trees and,
   from them, rule sets.

ingargiola@cis.temple.edu

from: http://www.cis.temple.edu/~ingargio/cis587/readings/id3-c45.html

    有m（m≥3）个球，记为q₁、q₂、…、q_m，其中有且仅有一个坏球，其重量与其他的不同，现使用无砝码的天平进行称量，令n为称量次数，问：能确保找到坏球并指出它与好球的轻重关系的n的最小值是多少？

    先来看理论上要多少次。每次称量有左边轻、平衡和右边轻共3种可能的情况，而坏球的可能结果有q₁轻、q₁重、q₂轻、q₂重、…、q_m轻、q_m重等共2m种。因此，根据商农的信息论，此问题的熵就是需要的称量次数，又因为n是整数，所以有：

    不过理论终归是理论，直接拿到现实生活中往往行不通。一个很简单的情况：4个球，上面的公式说2次称量就够了。但你可以想想办法，反正我是没找到两次解决问题的方案。

    那，是理论错了吗？唔，我可不敢怀疑商农，我只敢怀疑我自己。来看看我们错在哪了吧。对4个球的情况，第一次称量只有两个可选的方案：方案1：q₁放左盘，q₂放右盘。若不平衡（由于对称性，只分析左边轻的情况，下同），则可能的结果还剩q₁轻和q₂重，再称一次就能找到坏球；若平衡，则可能的结果还剩q₃轻、q₃重、q₄轻和q₄重4个，再套用一下商农的定理，此时还要称次。所以方案1被否决。方案2：q₁、q₂放左盘，q₃、q₄放右盘。此时天平肯定不会平衡，称量后，可能的结果有q₁轻、q₂轻、q₃重和q₄重4个。同样的道理，方案2也难逃被否决的命运。

    在4个球这么简单的情况下就撞得满头是包，未免让人难以接受，总结一下经验教训吧，把上面的分析归纳一下并推广到一般情况，就是：整个称量过程中，要达到目的，倒数第k次称量前的可能结果数h，必须满足条件h≤3^k。

    上面的得出的结论虽然不能让我们找到问题的答案，但却有助于我们确定每次称量的方案，特别是第一次如何做。假设我们计划的称量次数是n，第一次在左右两盘中各放x个球，则保证下面两个不等式同时成立是解决问题的必要条件：

    2(m-2x)≤3^n-1  （平衡时）

    2x≤3^n-1 （不平衡时）

把这两个不等式稍加变换，就成了下面的样子：

注意到x是整数，3n-1是奇数，2m是偶数，所以上面的不等式等价于：

显然，在n一定的情况下，m越大，x的取值范围越小，而当x只能取值时，m继续增大，就会导致n次称量找到坏球的计划破产。籍此，可以得出在n一定的情况下m的取值范围：。发现了吗？现在m的最大值正好比我们最初的结果少了1。同时此结果也与前面提到的4个球的实际情况相符。

    但分析了半天，我们只证明了m不在取值范围内时，n次称量不能确保找到坏球。那m在取值范围内的时候，肯定能找到吗？答案是肯定的，不过马上证明它有点难，先来看两个简单一点的命题。

    命题1：有A、B两组球，球的个数分别为a、b，且0≤b-a≤1，已知这些球中有且仅有一个坏球，若它在A组中，则比正常球轻，在B组中则比正常球重。另有一个好球。先使用无砝码的天平称量，令，则可以找到一个称量方案，使得最多经过n次称量，就可以找到坏球（此时肯定能指出它与好球的重量关系）。

    使用数学归纳法证明如下：

    ①当n=1时，a、b的取值可能有{0，1}、{1，1}、{1，2}三组，由于还有一个已知的好球，所以不难验证此时命题成立。
    ②假设当n=k时命题也成立。
    ③当n=k+1时。我们将A、B两组球分别尽量平均得分为三组，记为A1、A2、A3、B1、B2和B3。不影响一般性，假设这六组球按球数从少到多的排列次序也与前面的顺序一致，且A1有球a1个。则第一次称量时的称量方案与每组球个数的对应关系如下，其中需要注意的是：在带蓝色的两种情况下，必有，否则就与命题的前提不符了。

很明显，不管结果是什么，第一次称量之后，问题都能转化为n=k时的情形。所以，命题1是真命题。

    前面已经证明时，n次称量无法确保找到坏球并指出其轻重关系。但如果此时也有一个已知的好球的话，答案就不一样了，这时n次称量就已经足够（命题2）。仍使用数学归纳法。

    ①当n=2时，m=4，验证一下可知命题成立。 
    ②假设当n=k时命题也成立。 
    ③当n=k+1时。我们把这些球尽量平均的分成三组，则每组球的个数分别为：、、。第一次称量时，第一组和那个好球放左盘，第三组放右盘。若平衡，问题转化为n=k时的情形，不平衡，问题转化为命题1的情形。命题成立。

    有了前面两个证明作基础，最初的问题就很简单了，再次祭出数据学归纳法。由于m<5时的情况有些特殊(考虑只有一个球或两个球的情况)，不能作为递推得依据，所以我们从n=3，也就是m=5开始。

    ①当n=3时，m在5和12之间（13的情况已经被排除在外），通过一一验证可知命题成立。 
    ②假设当n=k时命题也成立。 
    ③当n=k+1时，找到一个满足不等式的x，在天平左右两盘中各放x个球。如果天平平衡，问题转化为n=k时的情形或命题2中的情形；不平衡，则转化为命题1的情形。命题成立。

    综上所述，称球问题的完整答案是：当球数时，n次称量时就能确保找到坏球，并指出它与好球的轻重关系；当球数时，n次称量只能确保找到坏球，而无法指出它与好球的轻重关系。要想指出轻重关系，就可能需要多进行一次称量。但如果此时再有一个好球，就又可以把这次称量省掉了。

from: http://blog.vckbase.com/localvar/archive/2005/07/17/9717.aspx

返回本讲概述

什么是计算与计算的类型

    在大众的意识里，计算首先指的就是数的加减乘除，其次则为方程的求解、函数的微分积分等；懂的多一点的人知道，计算在本质上还包括定理的证明推导。可以说，“计算”是一个无人不知元人不晓的数学概念，但是，真正能够回答计算的本质是什么的人恐怕不多。事实上，直到1930年代，由于哥德尔（K.Godel，1906-1978）、丘奇(A.Church，1903-1995)、图灵(A.M.TUI-ing，1912-1954)等数学家的工作，人们才弄清楚什么是计算的本质，以及什么是可计算的、什么是不可计算的等根本性问题。

    抽象地说，所谓计算，就是从一个符号串f变换成另一个符号串g。比如说,从符号串12+3变换成15就是一个加法计算。如果符号串f是，而符号串g是2x,从f到g的计算就是微分。定理证明也是如此，令f表示一组公理和推导规则，令g是一个定理,那么从f到g的一系列变换就是定理g的证明。从这个角度看，文字翻译也是计算，如f代表一个英文句子，而g为含意相同的中文句子，那么从f到g就是把英文翻译成中文。这些变换间有什么共同点？为什么把它们都叫做计算？因为它们都是从己知符号(串)开始，一步一步地改变符号(串)，经过有限步骤，最后得到一个满足预先规定的符号(串)的变换过程。

    从类型上讲，计算主要有两大类：数值计算和符号推导。数值计算包括实数和函数的加减乘除、幕运算、开方运算、方程的求解等。符号推导包括代数与各种函数的恒等式、不等式的证明,几何命题的证明等。但无论是数值计算还是符号推导,它们在本质上是等价的、一致的，即二者是密切关联的，可以相互转化，具有共同的计算本质。随着数学的不断发展,还可能出现新的计算类型。

计算的实质与E奇－图灵论点

    为了回答究竟什么是计算、什么是可计算性等问题，人们采取的是建立计算模型的方法。从20世纪30年代到40年代，数理逻辑学家相继提出了四种模型，它们是一般递归函数、λ可计算函数、图灵机和波斯特(E.L.Post，1897-1954)系统。这种种模型完全从不同的角度探究计算过程或证明过程，表面上看区别很大，但事实上却是等价的，即它们完全具有一样的计算能力D在这一事实基础上，最终形成了如今著名的丘奇-图灵论点：凡是可计算的函数都是一般递归函数(或是图灵机可计算函数等)。这就确立了计算与可计算性的数学含义。下面主要对一般递归函数作一简要介绍。

    哥德尔首先在1931年提出了原始递归函数的概念。所谓原始递归函数,就是由初始函数出发，经过有限次的使用代人与原始递归式而做出的函数。这里所说的初始函数是指下列三种函数：

    (1) 零函数0(x)=0(函数值恒为零)；

    (2) 射影函数(x1,x2,…,xn)=xi(1≤i≤n)(函数的值与第i个自变元的值相同)；

    后继函数S(x)=x+1(其值为x的直接后继数)。

    代人与原始递归式是构造新函数的算子。

    代人(又名叠置、迭置)，它是最简单又最重要的算子,其一般形式是:由一个m元函数f与m个n元函数g1，g2，…，gm造成新函数f(g1(x1,x2,…,xn),g2(x1,x2,…,xn),…,gm(x1,x2,…,xn))。

    原始递归式，其一般形式为

    特殊地为

其特点是，不能由g,h两已知函数直接计算新函数的一般值f(u,x),而只能依次计算f(u,0)，f(u,1)，f(u,2)，…；但只要依次计算，必能把任何一个f(u,x)，对值都算出来。换句话说，只要g,h有定义且可计算，则新函数f也有定义且可计算。

    根据埃尔布朗(J.Herbrand，1908-1931)一封信的暗示，哥德尔于1934年引进了一般递归函数的概念。后经克林(S.C.Kleene，1909-1994)的改进与阐明，便出现了现在普遍采用的定义。所谓一般递归函数，就是由初始函数出发，经过有限次使用代人、原始递归式和μ算子而做成的有定义的函数。 这里的μ算子就是造逆函数的算子或求根算子。

    如此定义的一般递归函数比原始递归函数更广，这是没有任何疑问的。但是，人们还是可以问：这样定义的函数是否已经包括了所有直观上的可计算函数？如果还有更广的可计算函数又该怎样定义？在受到这类问题困惑的同时，丘奇、克林又提出了一类可计算函数，叫做λ可计算函数。但事隔不久，丘奇和克林便分别证明了λ可计算函数正好就是一般递归函数，即这两类可计算函数是等价的、一致的。在这一有力的证据基础上，丘奇于1936年公开发表了他早在两年前就孕育过的一个论点，即著名的丘奇论点：每个能行地可计算的函数都是一般递归函数。

    与此同时，图灵定义了另一类可计算函数，叫做图灵机可计算性函数,并且提出了著名的图灵论点：能行可计算函数都是用图灵机可计算的函数。图灵机是图灵提出的一种计算模型，或一台理论计算机口它可以说是对人类计算与机器计算的最一般、最高度的抽象。一年后，图灵进一步证明了图灵机可计算函数与λ可定义函数是一致的，当然也就和一般递归函数一致、等价。于是，表面上不同的三类可计算函数在本质上就是一类。这样一来，丘奇论点和图灵论点也就是一回事了，现将它们合称为丘奇-图灵论点，即直观的能行可计算函数等同于一般递归函数、可λ定义函数和图灵机可计算函数。

    丘奇－图灵论点的提出，标志着人类对可计算函数与计算本质的认识达到了空前的高度，它是数学史上一块夺目的里程碑。

    一般递归函数比较抽象，为此给出一种较为直观的解释。大家知道，凡能够计算的，即使是“心算”，总可以把其计算过程记录下来，而且是逐个步骤逐个步骤地记录下来。所谓计算过程，是指从初始符号或已知符号开始，一步一步地改变(变换)符号，最后得到一个满足预先规定的条件的符号，并从该符号按照一定方法得到所求结果，即所求函数的值的全过程。可如此计算的函数，一般称为可以在有限步骤内计算的函数。现已证明：凡是可以从某些初始符号开始，而在有限步骤内计算的函数都是递归函数。由此可以看到，“能够记录下来”便符合了可计算性或递归性的本质要求。一般递归函数的实质也由此显得十分直观易懂。

    丘奇－图灵论点的提出与确认，在数学和计算机科学上具有重大的理论和现实意义。正如我国数理逻辑专家莫绍揆教授所言，有了这个论点以后，就可以断定某些问题是不能能行地解决或不能能行地判定的。对于计算机科学，丘奇-图灵论点的意义在于它明确刻画了计算机的本质或计算机的计算能力，确定了计算机只能计算一般递归函数，对于一般递归函数之外的函数，计算机是无法计算的。

DNA计算:新型计算方式的出现

    1994年11月，美国计算机科学家阿德勒曼(L.Adleman)在美国《科学》上公布DNA计算机的理论，并成功运用DNA计算机解决了一个有向哈密顿路径问题。 DNA计算机的提出，产生于这样一个发现，即生物与数学的相似性：(1)生物体异常复杂的结构是对由DNA序列表示的初始信息执行简单操作(复制、剪接)的结果；(2)可计算函数f(ω)的结果可以通过在ω上执行一系列基本的简单函数而获得。

    阿德勒曼不仅意识到这两个过程的相似性，而且意识到可以利用生物过程来模拟数学过程。更确切地说是，DNA串可用于表示信息，酶可用于模拟简单的计算。这是因为：首先，DNA是由称作核昔酸的一些单元组成，这些核昔酸随着附在其上的化学组或基的不同而不同。共有四种基：腺嘌呤、鸟嘌呤、胞嘧啶和胸腺嘧啶，分别用A、G、C、T表示。单链DNA可以看作是由符号A、G、C、T组成的字符串。从数学上讲，这意味着可以用一个含有四个字符的字符集∑ =A、G、C、T来为信息编码(电子计算机仅使用0和1这两个数字)。其次，DNA序列上的一些简单操作需要酶的协助，不同的酶发挥不同的作用。起作用的有四种酶：限制性内切酶，主要功能是切开包含限制性位点的双链DNA；DNA连接酶,它主要是把一个DNA链的端点同另一个链连接在一起；DNA聚合酶,它的功能包括DNA的复制与促进DNA的合成；外切酶，它可以有选择地破坏双链或单链DNA分子。正是基于这四种酶的协作实现了DNA计算。

    不过，目前DNA计算机能够处理的问题，还仅仅是利用分子技术解决的几个特定问题，属一次性实验。DNA计算机还没有一个固定的程式。由于问题的多样性，导致所采用的分子生物学技术的多样性，具体问题需要设计具体的实验方案口这便引出了两个根本性问题(也是阿德勒曼最早意识到的)：(1)DNA计算机可以解决哪些问题确切地说，DNA计算机是完备的吗？即通过操纵DNA能完成所有的(图灵机)可计算函数吗？(2)是否可设计出可编程序的DNA计算机？即是否存在类似于电子计算机的通用计算模型——图灵机——那样的通用DNA系统(模型)？目前，人们正处在对这两个根本性问题的研究过程之中口在笔者看来，这就类似于在电子计算机诞生之前的20世纪三四十年代理论计算机的研究阶段。如今，已经提出了多种DNA计算模型，但各有千秋，公认的DNA计算机的“图灵机”还没有诞生。相对而言，一种被称为“剪接系统”的DNA计算机模型较为成功。

    有了“剪接系统”这个DNA计算机的数学模型后，便可以来回答前面提出的DNA计算的完备性与通用性问题。前面讲过，丘奇-图灵论点深刻地刻画了任何实际计算机的计算能力——任何可计算函数都是可由图灵机计算的函数(一般递归函数)。现已证明：剪接系统是计算完备的，即任何可计算函数都可用剪接系统来计算D反之亦然。这就回答了DNA计算机可以解决哪些问题——全部图灵机可计算问题。至于是否存在基于剪接的可编程计算机，也有了肯定的答案：对每个给定的字符集T，都存在一个剪接系统，其公理集和规则集都是有限的，而且对于以T为终结字符集的一类系统是通用的。这就是说，理论上存在一个基于剪接操作的通用可编程的DNA计算机。这些计算机使用的生物操作只有合成、剪接(切割-连接)和抽取。

    DNA计算机理论的出现意味着计算方式的重大变革。当然，引起计算方式重大变革的远不止DNA计算机，光学计算机、量子计算机、蛋白质计算机等新型计算机模型层出不穷，它们使原有的计算方式发生了前所未有的变化。

计算方式及其演变

    简单地讲，所谓计算方式就是符号变换的操作方式，尤其指最基本的动作方式。广义地讲，还应包括符号的载体或符号的外在表现形式，亦即信息的表征或表达。比如，中国古代的筹算，就是用一组竹棍表征的计算方式，后来的珠算则是用算盘或算珠表征的计算方式，再后来的笔算又是一种用文字符号表征的计算方式，这一系列计算方式的变化，表现出计算方式的多样性与不断进化的趋势。相对于后来出现的机器计算方式，上述各种计算方式均可归结为“手工计算方式”，其特点是用手工操作符号，实施符号的变换。

    不过，真正具有革命性的计算方式，还是随着电子计算机的产生才出现的。机器计算的历史可以追溯到1641年，当年18岁的法国数学家帕斯卡从机械时钟得到启示：齿轮也能计数，于是成功地制作了一台齿轮传动的八位加法计算机口这使人类计算方式、计算技术进入了一个新的阶段。后来经过人们数百年的艰辛努力，终于在1945年成功研制出了世界上第一台电子计算机。从此，人类进入了一个全新的计算技术时代。

    从最早的帕斯卡齿轮机到今天最先进的电子计算机，计算机已经历了四大发展时期。计算技术有了长足的发展。这时计算表现为一种物理性质的机械的操作过程。符号不再是用竹棍、算珠、字母表征，而是用齿轮表征，用电流表征，用电压表征等等。但是，无论是手工计算还是机器计算，其计算方式——操作的基本动作都是一种物理性质的符号变换(具体是由“加”“减”这种基本动作构成)。二者的区别在于：前者是手工的，运算速度比较慢；后者则是自动的，运算速度极快。

    如今出现的DNA计算无疑有着更大的本质性变化，计算不再是一种物理性质的符号变换，而是一种化学性质的符号变换，即不再是物理性质的“加”“减”操作，而是化学性质的切割和粘贴、插人和删除。这种计算方式将彻底改变计算机硬件的性质，改变计算机基本的运作方式，其意义将是极为深远的。阿德勒曼在提出DNA计算机的时候就相信，DNA计算机所蕴涵的理念可使计算的方式产生进化。

    量子计算机在理论上的出现，使计算方式的进化又有了新的可能。电子计算机的理论模型是经典的通用图灵机——一种确定型图灵机，量子计算机的理论模型——量子图灵机则是一种概率型图灵机。直观一些说，传统电脑是通过硅芯片上微型晶体管电位的“开”和“关”状态来表达二进位制的0和1，从而进行信息数据的处理和储存。每个电位只能处理一个数据，非0即1，许多个电位依次串连起来，才能共同完成一次复杂的运算。这种线性计算方式遵循普通的物理学原则，具有明显的局限性。而量子计算机的运算方式则建立在原子运动的层面上，突破了分子物理的界限。根据量子论原理，原子具有在同一时刻处于两个不同位置、又同时向上下两个相反方向旋转的特性，称为“量子超态”。而一旦有外力干扰，模糊运动的原子又可以马上归于准确的定位。这种似是而非的混沌状态与人们熟知的常规世界相矛盾，但如果利用其表达信息，却能发挥出其瞬息之间千变万化而又万变不离其宗的神奇功效。因为当许多个量子状态的原子纠缠在一起时，它们又因量子位的“叠加性”，可以同时一起展开“并行计算”，从而使其具备超高速的运算能力。电子线性计算方式如同万只蜗牛排队过独木桥，而量子并行运算好比万只飞鸟同时升上天空。

计算方式演变的意义

    计算方式的不断进化有着十分重要的理论意义和现实意义，笔者认为至少表明以下两方面。其一，计算方式是一种历史的结果，而非计算本性的逻辑必然。加拿大的卡里(L.Kari)指出：“DNA计算是考察计算问题的一种全新方式。或许这正是大自然做数学的方法：不是用加和减，而是用切割和粘贴、用插入和删除。正如用十进制计数是因为我们有十个手指那样，或许我们目前计算中的基本功能仅因为人类历史使然。正如人们已经采用其他进制计数一样，或许现在是考虑其他的计算方式的时候了。”笔者以为，这一说法是很有启示性的。确实，仔细回顾一下人类计算方式或计算技术的历史,就不难体会到计算方式是一种历史的结果，而非计算本性的逻辑必然。

    也就是说，计算之所以为计算，在于它具有一种根本的递归性，或在于它是一种可一步一步进行的符号串变换操作。至于这种符号变换的操作方式如何，以及符号的载体或其外在表现形式如何，都不是本质性的东西，它们元不是一种历史的结果，无不处于一种不断变革或进化的过程之中。不同表征下的符号变换有着不同的操作方式，甚至同一种表征下的符号变换都可以有不同的操作方式：既可以是物理性的方式，也可以是化学性的方式；即可以是经典的方式,也可以是量子的方式；既可以是确定性的方式，也可以是概率性的方式。在此，计算本质的统一性与计算方式的多样性得到了深刻的体现。笔者相信，DNA计算机、量子计算机等的出现已经打开了人们畅想未来计算方式的思维视窗，随着科学技术的不断发展，计算方式的多样性还会有新的表现。

    其二，计算方式的历史性、多样性反观了计算本性的逻辑必然性、统一性。由丘奇-图灵论点所揭示的计算本质是非常普适的，它不仅包括数值计算、定理推导等不同形式的计算，而且包括人脑、电子计算机等不同“计算器”的计算。大家不要忘了，以丘奇-图灵论点为基石的可计算性理论是在电子计算机诞生之前的1930年代提出的，即它并非在对电子计算机进行总结与抽象的基础上提出，但又深刻地刻画了电子计算机的计算本质。如今最先进的电子计算机在本质上就是一台图灵机，或者凡是计算机可计算的函数都是一般递归函数。现在人们又进一步认识到，目前尚在实验室阶段的DNA计算机、量子计算机，在本质上也是一种图灵计算。这说明不同形式的计算、不同“计算器”的计算，在计算本质上是一致的，这就是递归计算或图灵计算。

转自：http://cfc.nankai.edu.cn/readings/lijie.htm