ZT go and Computer

I did not finish my work at the chess and chess forum seven years ago. I was planning to write five parts. At that time, I had to put aside my pen because I was not satisfied with the third part, so I had to move my hand late, but this unfinished work was posted everywhere.

Now, I plan to finish this article and make some modifications to the previous article. At the same time, we also hope that
This article can be published on a more formal occasion.

From earth to moon

Since the birth of computers, people are full of fantasies about computers. Some people are excited and worried about computers surpassing the human brain, especially in AI, but almost everyone once thought this would be true. Especially after "Deep Blue" Beat Kasparov, people have begun to worry that the computer will surpass the human brain and will it happen tomorrow?

But this worry is too early.

In the 70 or 80 s of this century, artificial intelligence scientists had a carefree childhood. They are ambitious and even have their computers replaced the human brain. In the table, it is time for computers to surpass the human brain. Now, "Deep Blue" does beat Kasparov, but the schedule of AI scientists has long been left behind. Someone even came up with a metaphor to illustrate the achievement of Artificial Intelligence: people want to climb the moon, they create a ladder, use this ladder to climb a tree, and then proudly claim: "Now, we have taken a big step towards the moon!"

Now, computers have penetrated into all aspects of our lives. In terms of production and life, we have been unable to imagine how to break away from computers, if these computers are just various ladders, it seems that they cannot be said.

Let's first look at what's going on with the ladder.

The inventor of the ladder is Dr Turing. When considering the nature of a computer that can be computed, Turing first imagined that a person was computing, and he abstracted the computing behavior of this person into such a machine: There was an infinite tape of paper, A machine with many statuses slides left and right on the tape, and can change its status or modify its content based on what it reads. This is the famous Turing machine. In theory, all current computers can be simulated by Turing machines.

Note that the Turing machine has an important capability: the ability to rewrite the tape. Without this capability, this machine is called a finite automatic machine. It has three different levels of computing power than the Turing machine. (Note: The machine that reads things on an infinite tape and writes things on the other tape also has a finite automatic machine ).

Judging the computing power of these things uses the concept of languages that these machines can accept. Although this language is an abstract language, it is similar to the language we usually call. You only need to understand what the machine can understand. Jordan divides the language into four levels: 0, 1, 2, and 3. the level 0 has the strongest capability and the Level 3 has the worst. There is an insurmountable gap between these four levels.

The Level 3 language here is also called a formal language, which can be understood by poor automatic functions. Level 2 language is called a context-independent language, meaning a word. You can understand it without considering its context. Level 1 language is context-related, that is to say, the machine has to figure out what it means. Zero-level language is the language acceptable to the Turing machine.
With the ability to count, we can understand the differences in abilities between 1, 2, and 3.

There is such a joke about the number of people: the first person who is talking about the number of people who say the number is bigger, the first one is racking his brains, thinking for ten minutes, said: 3, it's the second person's turn, he thought for a long time and finally said, "You have won.

The number of three skills can be used in all types of languages. I am talking about the number of skills from the beginning, as long as you don't die, you can count as many as you do. The Type 3 language, that is, the formal language, does not count. A 2-type language (context-independent language) can count, but it cannot count two numbers at the same time. Type 1 language can be used as many numbers as possible. In contrast, Type 0 has more capabilities than type 1. That is to say, the Turing machine looks simple, but it is actually quite cool.

However, Turing finds out that the Turing machine is still out of service. This is the downtime problem of the Turing machine. We can illustrate the downtime of the Turing machine in this way: If the Turing machine understands a sentence, it will not think about it any more. Now I give it a sentence and ask it, "Do you understand it ?" If it understands it, it will answer "yes", but if it does not understand it, it is likely that it will never know it.

Poor and infinite
The idea of boarding the moon with a ladder may seem ridiculous to modern people, but in the eyes of the ancients, it may not be so. A ladder can be built on a tree, a house, a city, or even a hill. Why cannot it go to heaven?
Because the number of raw materials used for building ladders is not enough, the intensity is not enough, and there is no place to build ladders, etc. But the Ancients do not know how far the Earth and the Moon are.

In theory, the changes of chess scales at the intersection of Go and 361 are limited. Therefore, theoretically, these problems can be solved by the Turing machine. However, when we draw a conclusion step by step in theory, we have already unknowingly crossed the limit of being poor and infinite in the practical computing sense.
Take go as an example. How many changes does go have? There are two ways to estimate. One is: assuming that no one is initiated and then starts from the beginning, there are 361 options in the first step and 360 options in the second step, in the future, we will take 361 as the border, and the number of changes will be 361 !, It is about 10 to the power of 768. Another estimation method is probably the first one used by Mr. Shen Kuo from the Song Dynasty: each vertex on the board has three states: black, white, and empty. Therefore, the number of Go changes is the power of 3 to 361, it is about 172 power to 10. In Mr Shen's statement, it is "Forty-three thousand words ". Although this is also very large, it is much smaller than the previous estimate. If such an estimation is correct, it would be much easier to use go on a computer.
Unfortunately, Mr. Shen's estimation method is incorrect. He only considered this kind of state, but did not consider the relationship between these States. For example, in a mathematical graph, Mr. Shen only considered the total number of vertices, but forgot to calculate the edge of the connected vertex.
If we do not consider the edge, we will consider the "Forty-three" state of the book. If I can accurately calculate the value for each State, then the computer only needs to check the value table to determine how to play the game. In this way, the number of changes that the computer needs to store is "Forty-three thousand yuan of books", but the problem is, how are these values calculated? You can guess the value of a State. Therefore, assume that there is a computer go machine, although he can only consider different States during execution.
But in order to create this machine, we have to take into account all the relationships of these States.
What is the concept of 10 to the power of 768 obtained by the first estimation method? It is estimated that the total number of all basic particles in the universe is at the power of 80. If there are no measures to simplify the computation, This is a number that is countless times larger than the total number of particles in the universe. For us, what is the difference with infinity?(This means that it is far from enough to make all known cosmic substances into memory, each atom, simply, and each quark stores a state-nn_1997)
In fact, the first estimation method is incorrect. the real number of changes in go cannot even be reached by the power of 10 (the power of 3). People with a college degree know that once there is an exponential ladder, the size of this number is unimaginable.

This does not mean that go is not actually feasible for the Turing machine.At least tell us that the Traversal method is not feasible.. So, we will take the go state for the moment as an infinite view.
Here, we use quasi-infinity as the number of States that reach the actual unmeasurable degree.

When talking about the comparison between go and chess, people generally say that go has changed much more than chess. However, the reason why it is difficult for a computer to play chess is inadequate. It is not that the more the state, the more complicated it is. Moreover, the change in chess is also an astronomical number..
However, if you enlarge the chess board and increase the number of chess pieces, the change will be close to or even greater than go in absolute values, chess can only give people the feeling of playing chess rather than playing Go. Because,Their "Syntax" is essentially different..
Now, let's consider the following question: how many positions do I have to judge when the status of chess and go games changes?
When I drop a game, I only need to consider the state of the sub-point. If there is my sub-point here, this step will not work. If there is an enemy sub-point here, the enemy is eaten by me. If it is blank, it is only the shift of the pawn. we can consider it as a special case that can be traversed, and we will not consider it for the moment.
Let's look back at level 2 in Level 4 Language: contextual language. after special circumstances are ruled out, we can consider that, since the status changes of a chess board are irrelevant to the surrounding area, it should be understandable (professionally accepted) machines in Level 2 languages understand this. we can understand chess as a context-independent language.

Back to go, what will happen to the board when we fall behind? If the enemy is surrounded by enemies and some are not angry, the enemy takes all of them away. If there is a child around, the enemy is not taken away, but the child is not angry, it is self-filled.
It sounds very simple, but the board changes need to be determined by the surrounding circumstances. If we only look at the state of the sub-point, we cannot reach any conclusion. that is to say, go cannot use context-independent languages for equivalence. At least it must use context-related languages, that is, it can count a lot of level 1 languages.
When considering the number of changes to go, we can't help but mention it. some people say that "robbery is the essence of go", but for type 1 language, robbery is really terrible. the basic requirement of a type 1 language is that the left side of the language production formula is no longer than the right side, but this is not the case for robbery. with the robbery, the type 1 language cannot accept go.
Even worse, it is still behind. like a three-robbery cycle, a four-robbery cycle, and a long-lasting robbery, in the current go rules, they are all simply judged as "no victory or defeat". In fact, if we use the "global same type to prohibit reproduction ", it can be solved theoretically, and it is not as complicated as people think (I may write another article to introduce the law of Multi-robbery loop in the future ). the global same-type reproduction prohibition is also fully explained. however, global same-type reproduction prohibition is a fatal blow to the simulation of go using a Turing machine. this means that this Turing machine has to store all the previous states, and the machines with an infinite number of States are not Turing machines.
One game of chess is over. There are three states: the opposite party will die, and the other party will die. In addition to the willingness of both parties, the two sides of the game also force and, three identical and, the number of 60 steps remains unchanged and so on, which means that chess can be directly tested, and the number of steps will not exceed 32*60 steps. it can be different from go. "reproduction is prohibited globally." This means that in theory, go can have so many orders of magnitude to the power of 3! This is quasi-infinite.
Without this rule, the number of steps that go can take is still infinite.
However, the victory or defeat of go can be determined only by looking at the status of the entire board. That is to say, even if there is no rule of "global equivalence prohibition reproduction", we can use a Turing Machine to accept go, however, judging the quality of each step must be traced back to the final point of the game, which means that the Turing machine will judge the state of the game when it is stopped under different circumstances! This is beyond the control of the Turing machine.
The state here is the theoretical state, which is different from the state we select in actual computing. The actual game of Go rarely exceeded 361 hands,This has inspired us that since chess and go are three different levels of complexity, (Is it true that the argument through the language theory of Jordan is strict? If so, it is undoubtedly a wonderful argument-nn_1997) Can we use algorithms that solve the chess problem to deal with go?

By the way, paste the third part. I don't like this part because I have no unique insights. I plan to cut this section and merge more content about optimization and path searching as the third part, focuses on the fourth part of "chaotic edge" and the fifth part of "between feeling and computing"

3-maze path
Theoretically, each step of Go has one or several optimal options. If we can traverse all the changes of Go and compare them, we can find these optimal methods, this traversal is actually not feasible.
The process of searching for the best way to go is like taking a huge maze. There are countless branches in the maze, some leading to the dead path, some leading to the illusion, and some other roads just turning around. in this huge maze, when we know that we can only walk through a tiny fraction of this maze for a lifetime, we will naturally stop, see if there are any patterns in the path of this maze.
First, we should simplify the problem, discard the global prohibition of reproduction, and do not consider the situation of three, four, and long-term robbery. in this way, when going through the maze, you do not have to judge whether a loop will appear (that is, a loop is taken back). The simplest way to do this kind of loop-free maze is to stick it to the dead side (for example, always stick to the left or always paste to the right), this is a type of traversal search, the term is called depth first traversal search (because it has to go to the header every time and then go back to the next one ).
Based on the calculation in the previous chapter, it takes about 10 ^ (3 ^ 361) to traverse the maze in depth first.

Therefore, we have no choice but to find another way to go through the maze. How can we meet our requirements?

The labyrinth walk we are talking about here is an algorithm that solves a problem. It is generally used to measure the complexity of an algorithm by the order of complexity. first of all, there is a problem with its own scale. For example, if chess is a 64-grid board, we can set the scale of the chess problem to 64, and go is the 361 intersection, we can set the scale of the go question to 361. if you want to set their scales to 8, 19, respectively, you can, but it is obviously not as natural as 64 and 361 when considering the problem.
The complexity of the algorithm to solve a problem is defined based on the scale of the problem and the number of computing steps function. Set n to the scale of the problem. If an algorithm requires n steps. the complexity of an algorithm is N. If an algorithm requires 2 ^ n steps (n two concatenation), the complexity is 2 ^ n. for the two algorithms, as long as the ratio of their complex functions is not greater than a constant, we call them of the same order. that is to say, an algorithm that requires a step of N is in the same order as an algorithm that requires a step of N. as long as my machine can increase the speed by one thousand times, the first algorithm can reach the original speed of the second algorithm. however, an algorithm with the number of steps being n ^ 2 is more complex than an algorithm with the number of steps being 1000N, because no matter how fast your machine is, it is very difficult to scale, the first algorithm is always complicated.
Therefore, we use O (N), O (N ^ 2 ),..., O (2 ^ N ),... to represent N, N ^ 2 ,..., 2 ^ N ,... the complexity of the same-order algorithm. note that here 2 ^ N is a 2 ^ n step number algorithm (actually any x ^ n (x> 1) algorithm for any polynomial step (O (N), O (N ^ 2 )... these algorithms are all complicated. for example, the number of steps in an algorithm is about 2 ^ N, and the second is n ^ 10. When n is 64 (ChEss scale), the former requires 1.84*10 ^ 19 steps, the latter requires 1.15*10 ^ 18 steps. The first step is more than 10 times longer than the second one. If the problem scale is 361 (go scale ), the latter requires 3.76*10 ^ 25 steps, while the former requires 4.69*10 ^ 108 steps. This time, the former is 100 billion times more complicated than the latter.
If a problem can be solved by finding an algorithm whose complexity is polynomial, we call it a P-type problem. What we need is an algorithm whose complexity is polynomial. That is to say, if go is a P-type problem, we think it can be solved. however, if we can only find the exponential algorithm (O (2 ^ N ).. and so on.
WhileThe number of steps required for the traversal of go is a Sorting Problem of exponential complexity, which is more complex than the problem of exponential complexity..
Among the various problems that people try to solve with computers, there are a large number of problems, such as the goods Lang problem and the backpack problem. There are hundreds of problems in total, which are known as NP problems. they are one type because people have proved that as long as one problem can be computed (that is, there is a polynomial algorithm), other problems can be computed,
But now,People would rather prove that they do not have polynomial algorithms than polynomial algorithms looking for these problems.
Is go an NP problem? I don't know. It seems that no, but since NP problems all have exponential complexity solutions, while go cannot find the exponential complexity solutions, it seems that go is much more complicated than NP problems..

However, to solve a problem, we cannot find the best solution. It is also a wise choice to leave behind. people's attitude towards many NP problems is: they cannot find the best answer, and the better answer is also good. "Deep Blue" will lose to Kasparov, but it also shows that "Deep Blue" does not find the best way, but it can already beat Kasparov in its overall score.
Among the various search algorithms, there is an A * search algorithm, also called the best search algorithm. It sets a valuation function for various situations of the problem. Suppose we choose the path with the smallest value, when searching the maze, the * algorithm determines the path to be selected based on the valuation function, and keeps using the actual price of the route
Value plus the next valuation function as the new valuation. when the new valuation is less than the previous valuation of another route, you can switch to another route to re-evaluate and search, which is a bit like the man's judgment when playing the game: you can't take a look at this. If you see it is probably not a line, you can try another way.
Theoretically, if the estimated function is always less than the value of the actual route, the * algorithm can always find the optimal solution. however, this is too difficult. we can also come up with the idea that if the valuation function of the * algorithm can be close to each other, we may find a better way to go. for example, if the * algorithm can reduce the selection point of the next hand to an average of six steps, the number of steps required to calculate a change will be reduced to an average of 20 steps, then the total computing workload is changed to 6 ^ 20 = 3.66*10 ^ 15, which is close to the acceptable computing workload of the computer.
The author once imagined a go AI model: linking all the pieces together as the basic unit, and then assigning attributes such as strength and influence based on the shape and eye position of the piece, use a mechanical model to analyze the global sphere of influence, and then select the approximate position of the next hand. in fact, this is an idea of a * algorithm's valuation function.
It seems that we only need to find a good method to quantify the go situation into appropriate values, and then perform a * search based on these values, we can find a pretty good way to go.
The only problem is:Is there a feasible quantification method?