4x4x4 盲拧

彳亍

经 偶尔路过 提议，开一个专贴，有兴趣高阶盲拧的同学，一起来研究吧。有问题有想法都可以提到这里，我们有最强的技术支持[em31]

彳亍

论坛现有的一点资料：

1、yahoo论坛四阶盲拧的例子.

http://bbs.mf8-china.com/viewthread.php?tid=2183&extra=page%3D7

2、发个四阶。以后慢慢学习。

http://bbs.mf8-china.com/viewthread.php?tid=2873&extra=page%3D6

3、【4x4x4】－棱块

http://bbs.mf8-china.com/viewthread.php?tid=3322&extra=page%3D1


4、[转帖]Chris 讲解的 commutator

http://bbs.mf8-china.com/viewthread.php?tid=3143&extra=page%3D3

（这个是盲拧的核心技术）

xiaozhuzy

gao shou 我三几都还不会

彳亍

先看看这个

http://www.speedsolving.com/showthread.php?t=201

cmhardw
How-To for big cube blindfolded solving

Hey everyone, this tutorial will end up being pretty long, since I have a lot to say on the subject.

Here is the first installment.

Contents: How to solve a 4x4x4 blindfolded using the freestyle cycling method. This method is 100% intuitive, and is also very fast at solving the cube. I personally have been able to solve a cube blindfolded in under 5 minutes using this approach, and this includes the time to recall the cycles.

Introduction: This approach is using a very intuitive way to come up with commutators or "algorithms" on the fly. Before you stop reading, know that learning a commutator type is the same thing as learning an "algorithm". You will need only 1-2 commutator types, "algorithms", to solve a 4x4x4 blindfolded. I actively use roughly 10-20 commutator types or "algorithms", depending on how you count, in my blindfolded solving. So even using this method to it's most advanced level, there still is not very much to learn since the method is ENITRELY intuitive and requires no memorization whatsoever.

Overview

What order do I use for memorization and solving?
Edges - Algorithms & Concepts
Special cases
Edge Parity
Centres - Algorithms & Concepts
Tips & Tricks
Application to a 5x5x5

The Good Stuff

1) What order do I use for memorization and solving?

Here is the order I use to memorize and solve, and why I memorize and solve this way.

Memorization:
1) Centers
2) Edges
3) Corner permutaion
4) Corner orientation

Solving:
1) Corner orientation
2) Corner permutation
2a) Leave parity, if it exists, as (UBL <-> UBR)
3) Edges
3a) correct parity if it exists using an alg that does not affect centers
4) Centers
4a) solve any center blocks created to speed up the solve (more on this in the tips and tricks section)
5:2b) Solve corner parity if it exists

Why memorize and solve in this order?

Let's approach this problem backwards a little bit. What's the easiest part of memorizing and solving a 4x4x4 cube? We will want to memorize this part last, and solve it first. This way you don't have to memorize it well, just take a mental snapshot, quickly put on the blindfold, and then solve that easiest part immediately. Out of the 4 steps to achieve to solve a 4x4x4, orienting the corners for me is by far the easiest step. So that is why I memorize it last and solve it first.

Ok now what is the next easiest step? Well to memorize the centers you have to deal with 24 centers, so that's a hard step. To memorize the edges you have to deal with 24 edges, so that's a hard step. That leaves the corner permutation with only 8 pieces. So memorize this part 2nd to last and solve it second. This way you can take close to a mental snapshot, but make sure you can still remember it after memorzing and executing corner orientation.

Ok so now how do we choose to memorize edges or centers first? Well now let's really think about things. Do we want to cross memorize and cross solve the two? Or do we want to memorize and solve in reverse order? To cross solve would work like this:

Memorize:
1) Edges; 2) Centers; 3) Corner permutation; 4) Corner orientation

Solve:
1) Corner orientation; 2) Corner permutation; 3) Edges; 4) centers

There is a problem with solving this way though, and this problem is interference. How much time will elapse from the time you finish solving centers until you solve centers? And how much from when you finish memorizing edges until you start solving edges? If you memorize Edges first and solve them 3rd that's 5 levels of interference. You have to memorize centers, both corner parts, and solve both corner parts before you start solving the edges. This means you have to memorize the edges very well to avoid this interference. For centers you also have 5 levels of interference. This means you have to memorize BOTH edges and centers very well before you start your solve, and this takes time.

Now what if you memorize and solve perfectly in reverse? What happens?

Memorize:
1) Edges; 2) Centers; 3) Corner permutation; 4) Corner orientation

Solve:
1) Corner orientation; 2) Corner permutation; 3) Centers; 4) Edges

Corners we already know is very efficient. But what about centers and edges? Centers have 4 levels of interference, and edges have 6 levels of interference. When we crossed centers and edges both had 5 levels of interference. Both sum to 10... so which is better?

I say having one have 6 levels and one have 4 is much better. This is because certain memory techniques are stronger than others. So use a strong method for the one with 6 levels and a weaker but faster one for the one with 4 levels of interference.

So which one do we give 6 levels of interference?

Ok now let's stop working backwards to solve this problem. Think about the beginning of a solve. How do we know which faces go where? There are no central most centers to use as guides, so what do we use? Corners? Edges? Centers?

I say centers, and here's why. What is the probability that you have zero centers in the correct location at the start of a solve? This probability is exactly zero! You will always have at least one center already on the correct face. If you don't simply rotate your cube and you will.

Big deal you say, you can do the same with the edges. But the four centers of the same color are completely indistinct. So having them on the right face is all you need, whereas for edges you need to have them in literally the right location out of 24 possible. A center has a 1/6 chance of being in the right location, an edge only 1/24.

This means that you could potentially have lots of centers already on the correct face simply by rotating your cube at the beginning of a solve. Why use cycles to put them on the right face when you can use cube rotations? From my experience I've never had fewer than 5 centers already on the correct face, and I have had as many as 11 already correct just by finding a clever way to rotate the cube before starting my memorization.

So maximizing solved centers before you start memorizing is clearly a good idea. But then do you memorize edges or centers first still? I say centers, because you already have spent some time getting a clear layout of all the centers of the cube from scanning all faces and trying to figure out which way to rotate the cube and get as many solved as you can. If the centers are already in your mind, why not use that to your advantage to speed up memorization a little bit? What if you only need to put one blue center on the blue face? If you memorize edges first you may not remember that and have to re-figure it out. I say use what little bit of knowledge you get about the centers to help you memorize them right now, right at the start.

So we end up with memorizing as:

1) Centers
2) Edges
3) Corner permutaion
4) Corner orientation

and solving as:

Solving:
1) Corner orientation
2) Corner permutation
3) Edges
4) Centers


Now memorizing and solving this way presents a couple problems. First off how do we handle corner parity? Secondly how do we handle edge parity?

Let's tackle the corner parity problem first. How do you solve this on a 4x4? For the 3x3 you use two edges and two corners and perform a PLL algorithm that swaps the two edges and the two corners. But here's the catch, the 4x4 doesn't have these two edge groups, you are direct solving the pieces. Also you don't notice this usually on a 4x4x4 since the centers are indistinct, but if you perform an odd permutation on corners you *MUST* also perform an odd permutation on centers. This means if you swap two corners you must also affect centers. That's bad if the centers are unsolved.

Here are the ways you can handle parity.

1) Create two edge groups that are swapped and use them to do a PLL alg that also contains the two swapped corners. You must do this after centers are solved already.
2) Solve everything on the whole cube except those two swapped corners, and use an algorithm that swaps just those two corners as the very last part of the solve.

I prefer option number 2 and here's why. At what point are you going to look at the corner permutation to determine if you have parity or not? You have to do this before memorizing the edge permutation, to make sure you create those two edge groups that are swapped. Are you going to look at the corner permutation after you memorize the centers? Are you going to use this valuable memorization time to do something completely useless, tracing the CP to see if you have parity or not? What if you don't have parity? You've wasted time to see that you don't have to do anything to handle parity. I prefer to just find out during the memorization of the corner permutation whether or not I have parity, and save it for last.

Ok, now how do you remember that you have corner parity throughout the ENTIRE solve? This is tricky. I always leave the same two corners swapped, UBL and UBR. This way you can just remember that you have parity, and you know parity means (UBL UBR) is your remaining corner cycle.

Ok so that handles corner parity. Now we need to handle the edge parity. Let's take a look at the typical parity alg:
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

How does this alg affect centers and why do we care? Well we'll be handling edge parity before the centers have been solved. So we need to make sure our alg is what I call "centers safe" or doesn't affect any centers.

This alg is not centers safe. It performs the centers cycle (frU blU) (flU brU) which is the same as rotating the top center group twice or 180 degrees. So add on an alg that flips it back.

So your new 4x4x4 edge parity alg is:
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 R L U2 L' R' U' R L U2 L' R' U'

or some other equivalent that rotates the top center twice after doing the parity swap.

And that is why I memorize and solve like I do. I'll handle the step 4a) above in the tips and tricks section. For now it is not important.

----------

Keep checking back for the later sections. I'll try to post this in installments though and ask for feedback in case I'm writing something in a weird way or something.

Chris

录

浩哥..能否翻譯一下？看不懂啊

Polunga

我也看不懂 但是很感兴趣

彳亍

发帖庆祝一下，成功一次，还原时间11分45，记忆未知，20分钟左右。

需要多练习了，慢慢把心得体会写上来。

  

[em10]

彳亍

记忆和还原过程如下：

1、角块记忆和还原可以用自己三阶的方法。但还原最好放在最后解决，因为使用的公式可能对心块产生影响。

2、棱块或是心块都是从固定的一个缓冲位置开始，每三块一组的循环。

  记忆：

   棱块与心块均是24块，我用 A～X  字母一一替代，记忆通常是两两组词

   因为组合比较多，而且不是所有组合都有形象的词汇，这里还是一个难点。

  还原：

   棱块从缓冲块 UBl 出发，顺序分析各个块的还原次序。 

   心块我用的缓冲位置是 Ubl 。还原的方法与棱块一样 －－公式就是  commutators ，直译成中文 “转换机”。

呵呵，这个词用的确实很形象。

ABC 三个块的循环，分成两大步四小步来完成。

第一步：   A --> B

           C --> B

   这里的B块如同一个容器，将A和C容纳进来，转换后在下一步分别释放出去；

第二步：  B-->A

          B-->C

   分别是第一步的逆过程。

烟头 公式产生的原理 一贴有很详细的阐述。现在也理解了网上为什么找不到 高阶 盲拧的“公式”的原因。

情况实在太多了，而且弄懂了上面的方法后，发现很轻松的就会“创造”出百来个公式，就算整理出来，也没精力去记他。反而是还原过程的自由性更有趣味。

[此贴子已经被作者于2007-11-10 22:32:26编辑过]

彳亍

棱块还原，如果使用 UBl 作为缓冲块，可以多考虑以下块：

1、U转：   UBl--> URb

2、U2转：  UBl--> UFr

3、U’转： UBl--> ULf

其他层不是很顺，但也比较有用的如

1、 l l2 l'

2、R B' R' , L' B L

3、B R (R2 R') B'

等等。实际碰到的循环情况会很复杂（500多种），可以将循环中的一个块转换到以上这些块的位置，这样至少已经解决了循环的一半，且不易出错。

彳亍

心块的还原一直是我比较发怵的部分。但反而只用了两天的时间就基本掌握。

可能有前面棱块基础的缘故。

缓冲块为 Ubl，三循环的另外两块所属层有以下几种情况：

1、上 上 （这个在纯色魔方里用不上）

2、上 中

3、上 下

4、中 中 （显然出现频率最高，又要细分为同面 、对面 、邻面的情况）

5、中 下

6、下 下 （在碰到小循环的时候可能用到）

熟悉每个块的位置和相互之间的关系，通过怎样的转动能相互交换，就是盲拧还原的要点了。

由于纯色魔方心块位置的随意性（4个心块不能判断本来的位置），在初期研究公式的时候比较吃力。建议给每个块编号，这样位置关系一目了然。