摩尔定律l制下的软g开发时代有一个非常有意思的现象Q”Andy giveth, and Bill taketh away.”。不CPU的主频有多快Q我们始l有办法来利用它Q而我们也陉在机器升U带来的E序性能提高中?/p>
我记着我大二的时候曾l做q一个五子棋的程序，当时的算法就是预先设计一些棋型（有优先Q，然后扫描盘Q对形势q行分析Q看看当前走哪部对自己最重要。当然下还要堵别hQ这需要互换双方的型再计。如果只一步，很可能被狡猾的对手欺骗，所以ؓ(f)了多惛_步，q需要递归和回朔。在当时的机器上Q算3步就基本上需?U左右的旉了。后来大学毕业收拾东西的时候找到这个程序，试了一下，发现?0步需要的旉也基本上感觉不出来了?/p>
不知道你是否有同L(fng)l历Q我们不知不觉的一直在享受着q样的免费午。可是，随着摩尔定律的提前终l，免费的午终I要q回厅R虽然硬件设计师q在努力QHyper Threading CPUQ多Z套寄存器Q相当于一个逻辑CPUQ得Pipeline可能满负荷Q多个Thread的操作有可能q行Q得多U程E序的性能?%-15%的提升；增加Cache定w也得包括Single-Thread和Multi-ThreadE序都能受益。也许这些还能帮助你一D|_(d)但问题是Q我们必d出改变，面对q个卛_到来的变革，你准备好了么Q?/p>
Concurrency Programming != Multi-Thread Programming。很多h都会(x)说MultiThreading谁不?x)，问题是，你是Z么?如何使用多线E的Q我从前做过一个类似AcdSee一L(fng)囑փ查看/处理E序Q我通常用它来处理我的数码照片。我在里面用了大量的多线E，不过主要目的是在囑փ处理的时候不要Block住UIQ所以将CPU Intensive的计部分用后台U程q行处理。而ƈ没有把对囑փ矩阵的运ƈ行分开?/p>
我觉得Concurrency Programming真正的挑战在于Programming Model的改变，在程序员的脑子里面要对自qE序怎样q行化有很清楚的认识Q更重要的是Q如何去实现Q包括架构、容错、实时监控等{）q种q行化，如何?strong>调试Q如何去试?/p>
在GoogleQ每天有量的数据需要在有限的时间内q行处理Q其实每个互联网公司都会(x)到q样的问题）Q每个程序员都需要进行分布式的程序开发，q其中包括如何分布、调度、监控以?qing)容错等{。Google?a >MapReduce正是把分布式的业务逻辑从这些复杂的l节中抽象出来，使得没有或者很ƈ行开发经验的E序员也能进行ƈ行应用程序的开发?/p>
MapReduce中最重要的两个词是MapQ映）和ReduceQ规U）。初看Map/Reduceq两个词Q熟(zhn)Function Language的h一定感觉很熟?zhn)。FP把这L(fng)函数UCؓ(f)”higher order function”（”High order function”被成ؓ(f)Function Programming的利器之一哦）Q也是_(d)q些函数是编写来被与其它函数相结合（或者说被其它函数调用的Q。如果说要比的化，可以把它惌成C里面的CallBack函数Q或者STL里面的Functor。比如你要对一个STL的容器进行查找，需要制定每两个元素相比较的FunctorQComparatorQ，q个Comparator在遍历容器的时候就?x)被调用?/p>
拿前面说q图像处理程序来举例Q其实大多数的图像处理操作都是对囑փ矩阵q行某种q算。这里的q算通常有两U，一U是映射Q一U是规约。拿两种效果来说Q”老照片”效果通常是强化照片的G/B|然后Ҏ(gu)个象素加一些随机的偏移Q这些操作在二维矩阵上的每一个元素都是独立的Q是Map操作。而”雕删Z效果需要提取图像边~，需要元素之间的q算了，是一UReduce操作。再举个单的例子Q一个一l矩阵（数组Q[0,1,2,3,4]可以映射为[0,2,3,6,8]Q乘2Q，也可以映ؓ(f)[1,2,3,4,5]Q加1Q。它可以规约?Q元素求U）也可以规Uؓ(f)10Q元素求和）?/p>
面对复杂问题Q古人教导我们要?strong>?/strong>?strong>?/strong>之”，英文中对应的词是?strong>Divide and Conquer“。Map/Reduce其实是Divide/Conquer的过E，通过把问题DivideQɘq些Divide后的Mapq算高度q行Q再Map后的l果ReduceQ根据某一个KeyQ，得到最l的l果?/p>
Googler发现q是问题的核心，其它都是共性问题。因此，他们把MapReduce抽象分离出来。这PGoogle的程序员可以只关心应用逻辑Q关心根据哪些Key把问题进行分解，哪些操作是Map操作Q哪些操作是Reduce操作。其它ƈ行计中的复杂问题诸如分布、工作调度、容错、机器间通信都交lMap/Reduce FrameworkdQ很大程度上化了整个~程模型?/p>
MapReduce的另一个特Ҏ(gu)QMap和Reduce?strong>输入和输出都是中间(f)时文?/strong>QMapReduce利用Google文gpȝ来管理和讉Kq些文gQ，而不是不同进E间或者不同机器间的其它通信方式。我觉得Q这是Google一贯的风格Q化Jؓ(f)Q返璞归真?/p>
接下来就放下其它Q研I一下Map/Reduce操作。（其它比如定w、备份Q务也有很l典的经验和实现Q论文里面都有详qͼ
Map的定义：(x)
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的定义：(x)
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论文中给Zq样一个例子：(x)在一个文档集合中l计每个单词出现的次数?/p>
Map操作的输入是每一文档，输入文档中每一个单词的出现输出C间文件中厅R?/p>
map(String key, String value):
// key: document name
// value: document contents
for each word w in value:
EmitIntermediate(w, ??;
比如我们有两文档，内容分别?/p>
A Q?“I love programming?/p>
B Q?“I am a blogger, you are also a blogger”?/p>
B文档l过Mapq算后输出的中间文g会(x)是：(x)
I,1 am,1 a,1 blogger,1 you,1 are,1 a,1 blogger,1
Reduce操作的输入是单词和出现次数的序列。用上面的例子来_(d)是 (”I? [1, 1]), (”love? [1]), (”programming? [1]), (”am? [1]), (”a? [1,1]) {。然后根据每个单词，出ȝ出现ơ数?/p>
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));
最后输出的最l结果就?x)是Q?”I? 2?, (”a? 2?…?/p>
实际的执行顺序是Q?/p>
- MapReduce LibraryInput分成M份。这里的Input Splitter也可以是多台机器q行Split?
- MasterM份Job分给Idle状态的M个worker来处理；
- 对于输入中的每一?lt;key, value> pair q行Map操作Q将中间l果Buffer在Memory里；
- 定期的（或者根据内存状态）Q将Buffer中的中间信息Dump?strong>本地盘上，q且把文件信息传回给MasterQMaster需要把q些信息发送给Reduce workerQ。这里最重要的一Ҏ(gu)Q?strong>在写盘的时候，需要将中间文g做PartitionQ比如R个）。拿上面的例子来举例Q如果把所有的信息存到一个文ӞReduce worker又会(x)变成瓉。我们只需要保?strong>相同Key能出现在同一个Partition里面可以把q个问题分解?
- R个Reduce worker开始工作，从不同的Map worker的Partition那里拿到数据Q?strong>read the buffered data from the local disks of the map workersQ，用keyq行排序Q如果内存中放不下需要用到外部排?- external sortQ。很昄Q排序（或者说GroupQ是Reduce函数之前必须做的一步?q里面很关键的是Q每个Reduce worker?x)去从很多Map worker那里拿到X(0<X<R) Partition的中间结果，q样Q所有属于这个Key的信息已l都在这个worker上了?
- Reduce worker遍历中间数据Q对每一个唯一KeyQ执行Reduce函数Q参数是q个key以及(qing)相对应的一pdValueQ?
- 执行完毕后，唤醒用户E序Q返回结果（最后应该有R份OutputQ每个Reduce Worker一个）?
可见Q这里的分（DivideQ体现在两步Q分别是输入分成M份，以及(qing)Map的中间结果分成R份。将输入分开通常很简单，Map的中间结果通常用”hash(key) mod R”这个结果作为标准，保证相同的Key出现在同一个Partition里面。当Ӟ使用者也可以指定自己的Partition FunctionQ比如，对于Url KeyQ如果希望同一个Host的URL出现在同一个PartitionQ可以用”hash(Hostname(urlkey)) mod R”作为Partition Function?/p>
对于上面的例子来_(d)每个文档中都可能?x)出现成千上万?(”the? 1)q样的中间结果，琐碎的中间文件必然导致传输上的损失。因此，MapReduceq支持用h供Combiner Function。这个函数通常与Reduce Function有相同的实现Q不同点在于Reduce函数的输出是最l结果，而Combiner函数的输出是Reduce函数的某一个输入的中间文g?/p>
Tom Whitel出了Nutch[2]中另一个很直观的例子，分布式Grep。我一直觉得，Pipe中的很多操作Q比如More、Grep、Cat都类g一UMap操作Q而Sort、Uniq、wc{都相当于某UReduce操作?/p>
加上前两天Google刚刚发布?a >BigTable论文Q现在Google有了自己的集?- Googel ClusterQ分布式文gpȝ - GFSQ分布式计算环境 - MapReduceQ分布式l构化存?- BigTableQ再加上Lock Service。我真的能感觉的到Google著名的免Ҏ(gu)之外的对于E序员的另一U免费的晚餐Q那个由大量的commodity PCl成的large clusters。我觉得q些才真正是Google的核心h(hun)值所在?/p>
呵呵Q就像微软老兵Joel SpolskyQ你应该看过他的”Joel on Software”吧Q）曄说过Q对于微软来说最可怕的是[1]Q微软还在苦苦追赶Google来完善Search功能的时候，Google已经在部|下一代的计算Z?/p>
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.
?Q其实，微Y也有自己的方?- DryAd。问题是Q大公司里，要想重新部vq样一个底层的InfraStructureQ无论是技术的原因Q还是政ȝ原因Q将是如何的难?/p>
?Q?a >Lucene之父Doug Cutting的又一力作QProject Hadoop - 由Hadoop分布式文件系l和一个Map/Reduce的实现组成，Lucene/Nutch的成产线也够齐全的了?br />
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.
About the Author: I'm your host, Joel Spolsky, a software developer in New York City. Since 2000, I've been writing about software development, management, business, and the Internet on this site. For my day job, I run Fog Creek Software, makers of FogBugz - the smart bug tracking software with the stupid name, and Fog Creek Copilot - the easiest way to provide remote tech support over the Internet, with nothing to install or configure.
from: http://www.joelonsoftware.com/items/2006/08/01.html
- General Idea
- Examples (in Scheme or in C)
- Interest
Program Specialization
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 PS 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.
Specialization Examples
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.
Interest of Specialization
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
append42above runs faster thanappend(or more precisely,triv-append42) because the traversal of argumentlist1as 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
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 PS:
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.
Applications of Partial Evaluation
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.
Off-line vs. On-line Partial Evaluation
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 PS.
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.
Binding-Time Analysis
As a first step, the user provides a program and specifies initial binding times, that is, which arguments (including global variables) are static (i.e., known) and which are dynamic (i.e., yet unknown). For example, the user provides the following code for aminiprintf function, and specifies that the first argument is static whereas the second is dynamic: miniprintf(S,D).
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.
Compile-Time Specialization
When the user is satisfied with the analysis (i.e., what the user expects to specialize is indeed considered as static by the BTA), actual specialization values must be provided. For example, giving"<%d|%d>" as the actual specialization value for the fmt argument of the miniprintf() function yields the following specialized code.
miniprintf_1(int val[]) { putchar( '<' ); putint ( val[0] ); putchar( '|' ); putint ( val[1] ); putchar( '>' ); }
Run-Time Specialization
Partial evaluators like Tempo [CHL+98,CHN+96] can also perform run-time specialization [CN96], using optimized binary code templates [NHCL97]. A dedicated run-time specializer is generated from the results of the program analysis. In the case of theminiprintf function, a runtime specializer rts_miniprintf() is generated, which can be used as in the following example.
/* * 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.
References
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.
Last modified: 2003-09-25. - Jocelyn.Frechot@labri.fr - http://compose.labri.fr
from: http://compose.labri.fr/documentation/pe/pe_overview.php3
密码学是理论计算机的一个很大的方向。之前准备先写密码学概论再提在hash函数破解上做出重大A(ch)献的王小云教授的工作Q不q前两天王小云获得求是杰出科学家奖以?00万奖?/a>Q在媒体上又掀起了一轮宣传狂潮，但是有些报道极端弱智Q错误百出，所以我机U正一下，q介l密码学的一个组成部分——hash函数Q以?qing)王云在这上面的工作?/p>
王小云的主要工作是关于hash函数的破解工作。她?005一个密码学?x)议上宣布破解了SHA-1Q震惊了全世界。所以要介绍和理解她的工作，先看一下hash函数具体是怎么回事?/p>
单的_(d)hash函数是把Q意长的输入字W串变化成固定长的输出字W串的一U函数。通俗得说Qhash函数用来生成信息的摘要。输出字W串的长度称为hash函数?strong>位数?/p>
目前应用最为广泛的hash函数?strong>SHA-1?strong>MD5Q大多是128位和更长?/p>
hash函数在现实生zM应用十分q泛。很多下载网站都提供下蝲文g的MD5码校验，可以用来判别文g是否完整。另外，比如在WordPress的数据库Q所有密码都是保存的MD5码，q样即数据库的理员也无法知道用户的原始密码，避免隐私泄露Q很多h在不同地斚w是用的同一个密码）?/p>
如果两个输入串的hash函数的gP则称q两个串是一?strong>撞(Collision)。既然是把Q意长度的字符串变成固定长度的字符Ԍ所以，必有一个输Z对应无穷多个输入Ԍ撞是必然存在的?/p>
一个“优良”的hash函数 f 应当满以下三个条gQ?/p>
上面的“非常困䏀的意思是除了枚D外不可能有别的更快的Ҏ(gu)。比如第3条，Ҏ(gu)生日定理Q要x到这L(fng)x1Qx2Q理Z需要大U?^(n/2)的枚举次数?/p>
几乎所有的hash函数的破解，都是指的破坏上面的第三条性质Q即扑ֈ一个碰撞（前两条都能被破坏的hash函数也太׃点，早就被h抛弃了）。在密码学上q有一个概忉|理论破解Q指的是提出一个算法，使得可以用低于理论值得枚Dơ数扑ֈ撞?/p>
王小云的主要工作是给ZMD5Q?a target="_blank">SHA-0
看到q里Q那些认Z国国安局应该这些结果封存作为秘密武器甚臛_想用q些成果来袭ȝ国之徒可以停住你们的YY了。这UŞ式上的破解，在大多数情况下没有实际性的作用。更别提MD5早就被美国h抛弃了?/p>
但是Q说q种破解一点实际意义都没有Q那׃׃q大密码学家的智商，密码学家不会(x)无缘无故的弄出碰撞这么一个概忉|。下面简单的介绍一下在特定情况下，怎么利用l定的碰撞来做坏?译?a target="_blank">Attacking Hash Functions)Q?/p>
Caesarl实?fn)生Alice叫写了一推荐信(letter)。同一天，Alice叫Caesar在推荐信上数字签名，q提供了一份推荐信的电(sh)子板。Caesar打开文gQ发现和原g一模一栗所以他在文件上{了名?/p>
几个月后QCaesar发现他的U密文g被非法察看。这到底是怎么回事呢？
a25f7f0b 29ee0b39 68c86073 8533a4b9
事实上，Alice要求Caesar{的文?a target="_blank">letter已经被Alice做了手脚Q准地_(d)Aliceq准备了另外一个文?a target="_blank">orderQ它们的MD5码完全一致。而Caesar的数字签名还依赖于MD5法Q所以Alice用order文g替换Letter文g之后QCaesar的数字签名依然有效。那orderlAlice提供了察看秘密文件的权限?/p>
具体的实现方法可?a target="_blank">Hash Functions and the Blind Passenger Attack。我在这里简单的解释一?只是大致思\Q具体实现方式，需要对文gl构信息有所了解)Q?/p>
letter文g的内Ҏ(gu)Q?/p>
if(x1==x1) show "letter" else show "order"
order文g的内Ҏ(gu)Q?/p>
if(x2==x1) show "letter" else show "order"
其中字符?letter"?order"代表两封信实际显C的内容。x1Qx2是一个MD5的碰撞?/p>
上面的方法，只供参考和学术用途，实际使用所引v的后果概不负责?/p>
参考：(x)
- 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
PSQ我跟王云老师的接触很，上过俩次她的讨论班而已Q亦感觉到王云老师的严谨和耐心。在d一个Turing奖获得者的演讲上，王小云提问的时候竟口而出“I ask who”的中式pQ在引v哄笑的同Ӟ我也极端佩服她的勇气。也许只有这h能做出非常好的工作吧?/p>
PS2: wikipedia在国内可以通过free_door览?
http://zhiqiang.org/blog/446.html
参阅: 王小?/a>,
概述Q?br />
假设?个schemaQS1和S2。我们要为S1里每一个元素在S2中找到匹配的元素?br /> q程如下Q?br /> 1. G1 = SQL2Graph(S1); G2 = SQL2Graph(S2); 把schema变成图，N用了Open Information Model (OIM)规格Q图中node采用矩Ş和卵形，矩Ş是文字描qͼ卵Ş是标识符
2. initialMap = StringMatch(G1, G2); 用字W串匚w做ؓ(f)初始匚wQ主要是比较通常的前~和后~Q这L(fng)l果通常是不准确?br />
3. product = SFJoin(G1, G2, initialMap); 用SF法生成l果?font color="#0000ff">假设两个不同的节Ҏ(gu)怼的，则它们邻接元素的怼度增加。经q一pd的P代，q种怼度会(x)传遍整个?br />
4. result = SelectThreshold(product); l果{?br />
SF法
图中的每条边Q用一个三元组表示QsQpQoQ，分别?源点Q边名，目的炏V?br />
怼度传播图Q首先定义pairwise connectivity graph(PCG) Q?((x; y); p; (x'; y')) 属于 PCG(A;B)<==>(x; p; x') ?A and (y; p; y') ?B?关键是p要相同，也就是边的名字一栗?/font>式子从右向左推导Q就可以A、B从两个模型徏立v它们的PCG?/font>图中的每个节点，都是A和B中的元素构成?元组Q叫做map pairs?br /> induced propagation graph。从PCG推导而来Q加上了反向的边Q边上注明了[传播pL]Qgؓ(f) 1/nQn为相应的边的数目?br /> 不动点计：(x)
设?x; y) > 0 代表了节点x ?A ?y ?B 的相似度Q是在整个 A X B的范围上定义的。我们把 Q(mo) 叫做 mapping。相似度的计就是基于?values的P代计。设 Q(mo)i 代表了第 i ơP代后的结果，Q(mo)0 是初始相似度Q可以用字符串相似度的办法的得出Q在我们的例子里Q没?Q(mo)0 Q即?Q(mo)0 =1Q?br /> 每次q代中，Q(mo)-values 都会(x)Ҏ(gu)光居paris?Q(mo)-values 乘以[传播pL] 来增加。例如，在第一ơP?Q(mo)1(a1; b1) = Q(mo)0(a1; b1) + Q(mo)0(a; b) * 0.5 = 1.5。类似的Q?sup>1(a, b) = Q(mo)0(a, b) + Q(mo)0(a1; b1) * 1.0 + Q(mo)0(a2, b1) *1.0 = 3.0。接下来Q所?Q(mo) D行正规化Q比如除以当前P代的 Q(mo)的最大|保证所?Q(mo) 都不大于1。所以在正规化以后，Q(mo)1(a; b) = 1.0, Q(mo)1(a1, b1) = 1.5/3.0 = 0.5。一般情况下QP代如下进行：(x)
上面的计进行P代，直到 Q(mo)n ?Q(mo)n-1之间的差别小于一个阈|如果计算没有聚合Q我们就在P代超q一定次数后停止。上?的第三副图，是5ơP代后的结果。表3时一些计方法，后面的实验表明，C比较好。A叫做 sparceQB叫做 exceptedQC叫做verbose
qo(h)
q代出的l果是一U[多匹配]Q可能包含有用的匚w子集?br /> 三个步骤Q?br /> 1。用E序定义的[限制条g]q行qo(h)?br /> 2。用双向图中的匹配上下文技术进行过?br /> 3。比较各U技术的有效性（满用户需求的能力Q?br /> 限制Q主要有两种Q一个是[cd]限制Q比如只考虑[列]的匹配（匚w双方都是列）。第二个?cardinality 限制Q即模式S1中的所有元素都要在S2中有一个映?br />
stable marriage问题Qn奛_n男配对，不存在这L(fng)两对 (x; y)?x0; y0)Q其中x喜欢 y0 胜过 yQ而且 y0 喜欢 x 胜过 x0。具有stable marriage的匹配结果的total satisfaction可能?x)比不具有stable marriage的匹配结果还低！
匚w质量的评?br />
基本的评估思想Q就是?用户对匹配结果做的修改越，匚w质量p高（修改l果包括L错误的pairQ加上正的pairQ?br /> n是找到的匚w敎ͼm是理想的匚w敎ͼc是用户作Z正的数目?br />
from: http://www.cnblogs.com/anf/archive/2006/08/15/477700.html
We are given a set of records. Each record has the same structure, consisting of a number of attribute/value pairs. One of these attributes represents the category of the record. The problem is to determine a decision tree that on the basis of answers to questions about the non-category attributes predicts correctly the value of the category attribute. Usually the category attribute takes only the values {true, false}, or {success, failure}, or something equivalent. In any case, one of its values will mean failure.
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 PlayNotice that in this example two of the attributes have continuous ranges, Temperature and Humidity. ID3 does not directly deal with such cases, though below we examine how it can be extended to do so. A decision tree is important not because it summarizes what we know, i.e. the training set, but because we hope it will classify correctly new cases. Thus when building classification models one should have both training data to build the model and test data to verify how well it actually works.
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 --------+-------------+---------+--------For a more complex example, here are files that provide records for a series of votes in Congress. The first file describes the structure of the records. The second file provides the Training Set, and the third the Test Set.
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
If there are n equally probable possible messages, then the probability p of each is 1/n and the information conveyed by a message is -log(p) = log(n). [In what follows all logarithms are in base 2.] That is, if there are 16 messages, then log(16) = 4 and we need 4 bits to identify each message.
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))For example, if P is (0.5, 0.5) then I(P) is 1, if P is (0.67, 0.33) then I(P) is 0.92, if P is (1, 0) then I(P) is 0. [Note that the more uniform is the probability distribution, the greater is its information.]
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
The ID3 algorithm is used to build a decision tree, given a set of non-categorical attributes C1, C2, .., Cn, the categorical attribute C, and a training set T of records.
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.
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 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. 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
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".
Using Gain Ratios
The notion of Gain introduced earlier tends to favor attributes that have a large number of values. For example, if we have an attribute D that has a distinct value for each record, then Info(D,T) is 0, thus Gain(D,T) is maximal. To compensate for this Quinlan suggests using the following ratio instead of Gain:
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
C4.5 introduces a number of extensions of the original ID3 algorithm.
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.
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
The decision tree built using the training set, because of the way it was built, deals correctly with most of the records in the training set. In fact, in order to do so, it may become quite complex, with long and very uneven paths.
Color
/ \
red/ \blue
/ \
Success Failure
You can run the C45 program here [you need to have an X-server and to allow access (xhost) from yoda.cis.temple.edu].
Classification Models in the Undergraduate AI Course
It is easy to find implementations of ID3. For example, a Prolog program by Shoham and a nice Pailmodule.
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.
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
什么是计算与计的cd
在大众的意识里，计算首先指的是数的加减乘除Q其ơ则为方E的求解、函数的微分U分{；懂的多一点的人知道，计算在本质上q包括定理的证明推导。可以说Q“计”是一个无Z知元Z晓的数学概念Q但是，真正能够回答计算的本质是什么的人恐怕不多。事实上Q直?930q代Q由于哥德尔QK.GodelQ?906-1978Q、丘?A.ChurchQ?903-1995)、图?A.M.TUI-ingQ?912-1954){数学家的工作，Z才弄清楚什么是计算的本质，以及(qing)什么是可计的、什么是不可计算的等Ҏ(gu)性问题?/FONT>
抽象地说Q所谓计，是从一个符号串f变换成另一个符号串g。比如说,从符号串12+3变换?5是一个加法计。如果符号串f?IMG height=15 src="http://cfc.nankai.edu.cn/readings/image/lijie/1.jpg" width=15>Q而符号串g?x,从f到g的计就是微分。定理证明也是如此，令f表示一l公理和推导规则Qo(h)g是一个定?那么从f到g的一pd变换是定理g的证明。从q个角度看，文字译也是计算Q如f代表一个英文句子，而g为含意相同的中文句子Q那么从f到g是把英文翻译成中文。这些变换间有什么共同点Qؓ(f)什么把它们都叫做计？因ؓ(f)它们都是从己知符??开始，一步一步地改变W号(?Q经q有限步骤，最后得C个满预先规定的W号(?的变换过E?/FONT>
从类型上Ԍ计算主要有两大类Q数D和W号推导。数D包括实数和函数的加减乘除、幕q算、开方运、方E的求解{。符h导包括代C各种函数的恒{式、不{式的证?几何命题的证明等。但无论是数D还是符h?它们在本质上是等L(fng)、一致的Q即二者是密切兌的，可以怺转化Q具有共同的计算本质。随着数学的不断发?q可能出现新的计类型?/FONT>
计算的实质与E奇－囄论点
Z回答I竟什么是计算、什么是可计性等问题Qh们采取的是徏立计模型的Ҏ(gu)。从20世纪30q代?0q代Q数理逻辑学家相提出了四U模型，它们是一般递归函数、d计算函数、图灉|和L斯特(E.L.PostQ?897-1954)pȝ。这U种模型完全从不同的角度探究计算q程或证明过E，表面上看区别很大Q但事实上却是等L(fng)Q即它们完全h一L(fng)计算能力D在这一事实基础上，最lŞ成了如今著名的丘?囄论点Q凡是可计算的函数都是一般递归函数(或是囄机可计算函数{?。这q立了计算与可计算性的数学含义。下面主要对一般递归函数作一要介l?/FONT>
哥d?dng)首先?931q提Z原始递归函数的概c(din)所谓原始递归函数,是由初始函数出发，l过有限ơ的使用代h与原始递归式而做出的函数。这里所说的初始函数是指下列三种函数Q?/FONT>
(1) 零函?(x)=0(函数值恒为零)Q?/FONT>
(2) 媄函数
(x1,x2,?xn)=xi(1≤i≤n)(函数的gWi个自变元的值相?Q?/FONT>
后函数S(x)=x+1(其gؓ(f)x的直接后l数)?/FONT>
代h与原始递归式是构造新函数的算子?/FONT>
代h(又名叠置、P|?Q它是最单又最重要的算?其一般Ş式是:׃个m元函数f与m个n元函数g1Qg2Q…，gm造成新函数f(g1(x1,x2,?xn),g2(x1,x2,?xn),?gm(x1,x2,?xn))?/FONT>
原始递归式，其一般Ş式ؓ(f)
Ҏ(gu)Cؓ(f)
其特Ҏ(gu)Q不能由g,h两已知函数直接计新函数的一般值f(u,x),而只能依ơ计f(u,0)Qf(u,1)Qf(u,2)Q…；但只要依ơ计，必能把Q何一个f(u,x)Q对值都出来。换句话_(d)只要g,h有定义且可计，则新函数f也有定义且可计算?/FONT>
Ҏ(gu)埃尔布朗(J.HerbrandQ?908-1931)一信的暗C，哥d?dng)?934q引q了一般递归函数的概c(din)后l克?S.C.KleeneQ?909-1994)的改q与阐明Q便出现了现在普遍采用的定义。所谓一般递归函数Q就是由初始函数出发Q经q有限次使用代h、原始递归式和μ子而做成的有定义的函数?q里的μ算子就是造逆函数的子或求根算子?/FONT>
如此定义的一般递归函数比原始递归函数更广Q这是没有Q何疑问的。但是，Zq是可以问：(x)q样定义的函数是否已l包括了所有直观上的可计算函数Q如果还有更q的可计函数又该怎样定义Q在受到q类问题困惑的同Ӟ丘奇、克林又提出了一cd计算函数Q叫做d计算函数。但事隔不久Q丘奇和克林便分别证明了λ可计函数正好就是一般递归函数Q即q两cd计算函数是等L(fng)、一致的。在q一有力的证据基上，丘奇?936q公开发表了他早在两年前就孕育q的一个论点，卌名的丘奇论点Q每个能行地可计的函数都是一般递归函数?/FONT>
与此同时Q图灵定义了另一cd计算函数Q叫做图灉|可计性函?q且提出了著名的囄论点Q能行可计算函数都是用图灉|可计的函数。图灉|是图灉|出的一U计模型，或一台理机口它可以说是对hc计与机器计算的最一般、最高度的抽象。一q后Q图灵进一步证明了囄机可计算函数与d定义函数是一致的Q当然也和一般递归函数一致、等仗于是，表面上不同的三类可计函数在本质上就是一cR这样一来，丘奇论点和图灵论点也是一回事了，现将它们合称Z?囄论点Q即直观的能行可计算函数{同于一般递归函数、可λ定义函数和图灉|可计函数?/FONT>
丘奇Q图灵论点的提出Q标志着人类对可计算函数与计本质的认识辑ֈ了空前的高度Q它是数学史上一块夺目的里程?/FONT>
一般递归函数比较抽象Qؓ(f)此给ZU较为直观的解释。大家知道，凡能够计的Q即使是“心”，d以把其计过E记录下来，而且是逐个步骤逐个步骤地记录下来。所谓计过E，是指从初始符h已知W号开始，一步一步地改变(变换)W号Q最后得C个满预先规定的条g的符Pq从该符h照一定方法得到所求结果，x求函数的值的全过E。可如此计算的函敎ͼ一般称为可以在有限步骤内计的函数。现已证明：(x)凡是可以从某些初始符号开始，而在有限步骤内计的函数都是递归函数。由此可以看刎ͼ“能够记录下来”便W合了可计算性或递归性的本质要求。一般递归函数的实质也由此昑־十分直观易懂?/FONT>
丘奇Q图灵论点的提出与确认，在数学和计算机科学上h重大的理论和现实意义。正如我国数理逻辑专家莫绍揆教授所aQ有了这个论点以后，可以断定某些问题是不能能行地解x不能能行地判定的。对于计机U学Q丘?囄论点的意义在于它明确ȝ了计机的本质或计算机的计算能力Q确定了计算机只能计一般递归函数Q对于一般递归函数之外的函敎ͼ计算机是无法计算的?/FONT>
DNA计算:新型计算方式的出?/FONT>
1994q?1月，国计算机科学家阿d勒曼(L.Adleman)在美国《科学》上公布DNA计算机的理论Qƈ成功q用DNA计算决了一个有向哈密顿路径问题?DNA计算机的提出Q生于q样一个发玎ͼ即生物与数学的相似性：(x)(1)生物体异常复杂的l构是对由DNA序列表示的初始信息执行简单操?复制、剪?的结果；(2)可计函数f(ω)的结果可以通过在ω上执行一pd基本的简单函数而获得?/FONT>
阿d勒曼不仅意识到这两个q程的相似性，而且意识到可以利用生物过E来模拟数学q程。更切地说是，DNA串可用于表示信息Q酶可用于模拟简单的计算。这是因为：(x)首先QDNA是由UC核昔酸的一些单元组成，q些核昔酔R着附在其上的化学组或基的不同而不同。共有四U基Q腺嘌呤、鸟嘌呤、胞(yu)嘧啶和胸腺嘧Ӟ分别用A、G、C、T表示。单链DNA可以看作是由W号A、G、C、Tl成的字W串。从数学上讲Q这意味着可以用一个含有四个字W的字符集∑ =A、G、C、T来ؓ(f)信息~码(?sh)子计算Z使用0?q两个数?。其ơ，DNA序列上的一些简单操作需要酶的协助，不同的酶发挥不同的作用。v作用的有四种Ӟ(x)限制性内切酶Q主要功能是切开包含限制性位点的双链DNAQDNAq接?它主要是把一个DNA铄端点同另一个链q接在一PDNA聚合?它的功能包括DNA的复制与促进DNA的合成；外切Ӟ它可以有选择地破坏双链或单链DNA分子。正是基于这四种酶的协作实现了DNA计算?/FONT>
不过Q目前DNA计算够处理的问题Q还仅仅是利用分子技术解决的几个特定问题Q属一ơ性实验。DNA计算没有一个固定的E式。由于问题的多样性，D所采用的分子生物学技术的多样性，具体问题需要设计具体的实验Ҏ(gu)口这便引Z两个Ҏ(gu)性问?也是阿d勒曼最早意识到?Q?1)DNA计算机可以解军_些问题确切地_(d)DNA计算机是完备的吗Q即通过操纵DNA能完成所有的(囄?可计函数吗Q?2)是否可设计出可编E序的DNA计算机？x否存在类g?sh)子计算机的通用计算模型——图灉|——那L(fng)通用DNApȝ(模型)Q目前，Z正处在对q两个根本性问题的研究q程之中口在W者看来，q就cM于在?sh)子计算生之前?0世纪三四十年代理机的研IDc(din)如今，已经提出了多UDNA计算模型Q但各有千秋Q公认的DNA计算机的“图灉|”还没有诞生。相对而言Q一U被UCؓ(f)“剪接系l”的DNA计算机模型较为成功?/FONT>
有了“剪接系l”这个DNA计算机的数学模型后，便可以来回答前面提出的DNA计算的完备性与通用性问题。前面讲q，丘奇-囄论点深刻地刻MM实际计算机的计算能力——Q何可计算函数都是可由囄的函数(一般递归函数)。现已证明：(x)剪接pȝ是计完备的Q即M可计函数都可用剪接pȝ来计D反之亦然。这回{了DNA计算机可以解军_些问题——全部图灉|可计问题。至于是否存在基于剪接的可编E计机Q也有了肯定的答案：(x)Ҏ(gu)个给定的字符集TQ都存在一个剪接系l，其公理集和规则集都是有限的，而且对于以T为终l字W集的一cȝl是通用的。这是_(d)理论上存在一个基于剪接操作的通用可编E的DNA计算机。这些计机使用的生物操作只有合成、剪?切割-q接)和抽取?/FONT>
DNA计算机理论的出现意味着计算方式的重大变革。当Ӟ引v计算方式重大变革的远不止DNA计算机，光学计算机、量子计机、蛋白质计算机等新型计算机模型层ZIP它们使原有的计算方式发生了前所未有的变化?/FONT>
计算方式?qing)其演?/FONT>
单地Ԍ所谓计方式就是符号变换的操作方式Q尤其指最基本的动作方式。广义地Ԍq应包括W号的蝲体或W号的外在表现Ş式，亦即信息的表征或表达。比如，中国古代的筹，是用一l竹表征的计算方式Q后来的珠算则是用算盘或珠表征的计方式，再后来的W算又是一U用文字W号表征的计方式，q一pd计算方式的变化，表现方式的多样性与不断q化的趋ѝ相对于后来出现的机器计方式，上述各种计算方式均可归结为“手工计方式”，其特Ҏ(gu)用手工操作符P实施W号的变换?/FONT>
不过Q真正具有革命性的计算方式Q还是随着?sh)子计算机的产生才出现的。机器计的历史可以q溯?641q_(d)当年18岁的法国数学家帕斯卡从机械时钟得到启C：(x)齿轮也能计数Q于是成功地制作了一台轮传动的八位加法计算机口q人类计算方式、计技术进入了一个新的阶Dc(din)后来经qh们数癑ֹ的艰辛努力，l于?945q成功研制出了世界上W一台电(sh)子计机。从此，人类q入了一个全新的计算技术时代?/FONT>
从最早的帕斯卡轮机C天最先进的电(sh)子计机Q计机已经历了四大发展时期。计技术有了长的发展。这时计表Cؓ(f)一U物理性质的机械的操作q程。符号不再是用竹、算珠、字母表征，而是用轮表征，用电(sh)表征，用电(sh)压表征等{。但是，无论是手工计还是机器计，其计方式——操作的基本动作都是一U物理性质的符号变?具体是由“加”“减”这U基本动作构?。二者的区别在于Q前者是手工的，q算速度比较慢；后者则是自动的Q运速度极快?/FONT>
如今出现的DNA计算无疑有着更大的本质性变化，计算不再是一U物理性质的符号变换，而是一U化学性质的符号变换，即不再是物理性质的“加”“减”操作，而是化学性质的切割和_脓(chung)、插人和删除。这U计方式将d改变计算机硬件的性质Q改变计机基本的运作方式，其意义将是极为深q的。阿德勒曼在提出DNA计算机的时候就怿QDNA计算机所蕴涵的理念可使计的方式产生q化?/FONT>
量子计算机在理论上的出现Q计算方式的进化又有了新的可能。电(sh)子计机的理论模型是l典的通用囄机——一U确定型囄机，量子计算机的理论模型——量子图灉|则是一U概率型囄机。直观一些说Q传l电(sh)脑是通过芯片上微型晶体电(sh)位的“开”和“关”状态来表达二进位制??Q从而进行信息数据的处理和储存。每个电(sh)位只能处理一个数据，??Q许多个?sh)位依次串连hQ才能共同完成一ơ复杂的q算。这U线性计方式遵循普通的物理学原则，h明显的局限性。而量子计机的运方式则建立在原子运动的层面上，H破了分子物理的界限。根据量子论原理Q原子具有在同一时刻处于两个不同位置、又同时向上下两个相反方向旋转的Ҏ(gu)，UCؓ(f)“量子超态”。而一旦有外力q扰Q模p运动的原子又可以马上归于准的定位。这U似是而非的沌状态与Z熟知的常规世界相矛盾Q但如果利用其表达信息，却能发挥出其瞬息之间千变万化而又万变不离其宗的神奇功效。因为当许多个量子状态的原子U缠在一hQ它们又因量子位的“叠加性”，可以同时一起展开“ƈ行计”，从而其具备超高速的q算能力。电(sh)子线性计方式如同万只蜗牛排队过独木桥，而量子ƈ行运好比万只飞鸟同时升上天I?/FONT>
计算方式演变的意?/FONT>
计算方式的不断进化有着十分重要的理论意义和现实意义Q笔者认表明以下两斚w。其一Q计方式是一U历史的l果Q而非计算本性的逻辑必然。加拿大的卡?L.Kari)指出Q“DNA计算是考察计算问题的一U全新方式。或许这正是大自然做数学的方法：(x)不是用加和减Q而是用切割和_脓(chung)、用插入和删除。正如用十进制计数是因ؓ(f)我们有十个手指那P或许我们目前计算中的基本功能仅因Zhcd史然。正如h们已l采用其他进制计CP或许现在是考虑其他的计方式的时候了。”笔者以为，q一说法是很有启C性的。确实，仔细回顾一下hc计方式或计算技术的历史,׃难体?x)到计算方式是一U历史的l果Q而非计算本性的逻辑必然?/FONT>
也就是说Q计之所以ؓ(f)计算Q在于它h一U根本的递归性，或在于它是一U可一步一步进行的W号串变换操作。至于这U符号变换的操作方式如何Q以?qing)符L(fng)载体或其外在表现形式如何Q都不是本质性的东西Q它们元不是一U历史的l果Q无不处于一U不断变革或q化的过E之中。不同表征下的符号变换有着不同的操作方式，甚至同一U表征下的符号变换都可以有不同的操作方式Q既可以是物理性的方式Q也可以是化学性的方式Q即可以是经典的方式,也可以是量子的方式；既可以是定性的方式Q也可以是概率性的方式。在此，计算本质的统一性与计算方式的多h得C深刻的体现。笔者相信，DNA计算机、量子计机{的出现已经打开了h们畅x来计方式的思维视窗Q随着U学技术的不断发展Q计方式的多样性还?x)有新的表现?/FONT>
其二Q计方式的历史性、多h反观了计算本性的逻辑必然性、统一性。由丘奇-囄论点所揭示的计本质是非常普适的Q它不仅包括数D、定理推导等不同形式的计，而且包括、电(sh)子计机{不同“计器”的计算。大家不要忘了，以丘?囄论点为基石的可计性理论是在电(sh)子计机诞生之前?930q代提出的，卛_q在对?sh)子计算行ȝ与抽象的基础上提出，但又深刻地刻M?sh)子计算机的计算本质。如今最先进的电(sh)子计机在本质上是一台图灉|Q或者凡是计机可计的函数都是一般递归函数。现在h们又q一步认识到Q目前尚在实验室阶段的DNA计算机、量子计机Q在本质上也是一U图灵计。这说明不同形式的计、不同“计器”的计算Q在计算本质上是一致的Q这是递归计算或图灵计?BR>
转自Q?A >http://cfc.nankai.edu.cn/readings/lijie.htm