The New Method / Substep / Concept Idea Thread

[TheNextFeliks]

Keyhole can actually be both edges or corners.

 

[Renslay]

Keyhole can actually be both edges or corners.

Indeed. The Sexy Method also uses corner-inserting keyhole.

 

[Renslay]

I had an idea called MCOECP

1. Solve the MIDDLE layer. About 8-9 moves, pretty easy and intuitive. This is where I get the M

2. Orient all corners. There is probably like 200 algs for this so maybe it could be split in 2 steps but say 11-17 moves. This is the CO.

3 and 4. Orient then permute all edges with 2 algorithms. I think you only need 7 algs for orientation. Probably about 21 moves. This is E

5. Permute all corners maybe 13 moves. CP

Probably a lot to learn, but who knows. I had a far fetched but plausible idea for advanced cubes to do middle layer then an alg for putting all peices in the right layer AND Orienting edges then just doing ZBLL on both sides.

Edit: that wouldn't work because you would have parity or something.

This is called the Belt Method. See also "Variants".

 

[Renslay]

Aaargh why can't I come up with something that hasn't been done???? Sigh....

Before you want to come up with something new, please carefully examine these graphs:
http://www.speedsolving.com/forum/showthread.php?46753-A-rubik-s-cube-methods-and-states-map
https://www.dropbox.com/s/3m7u4oyawj89nyl/MethodsStepsGraphV2_big.png

If you have something that is NOT on this graph, then you might (just might...) invented a new method.

 

[Dane man]

Before you want to come up with something new, please carefully examine these graphs:
http://www.speedsolving.com/forum/showthread.php?46753-A-rubik-s-cube-methods-and-states-map
https://www.dropbox.com/s/3m7u4oyawj89nyl/MethodsStepsGraphV2_big.png

If you have something that is NOT on this graph, then you might (just might...) invented a new method.

Woah, cool graph! I didn't see Diaper, ZBLBL, or SF2L so that makes me happy to know that I understood enough methods to avoid repeating myself. Though I expected to see BLL there (and I did) because it was what seemed to me the most natural progression when I figured it out.

I've gotta come up with something different yet just as efficient if not more so than other methods. That's my goal.

 

[G2013]

I think I have something no one has seen. I call it the Aw method or 23CCLLP5EO5EL3E but that's a little long.

I thought of this when I realized people often try to solve layer by layer up the cube but what if you solved up with the cube standing on one corner?

1. Solve 2x2x2 block. For the sake of my description, let the corner in you 2x2 be FLD. This is intuitive.

2. Solve Corners ULF, FRD, and BLD. This is intuitive.

3. Do 1 of 42 CLL algorithms, but they instead of effecting the corners on the top layer, effect the corners UFR, UBL, BRD, and UBR.

4. Do 1 of I don't know because I'm bad at math algorithms to permute and orient the edges in FR, BL, and BR.

5. Solve with slightly modified Roux.

My estimate is 5+9+11+10+15 moves which is 50.

Crossing my fingers that nobody has thought of this...

It is interesting, but not practical for speed. I made a try with commutators. If someone improves that method, could result into something interesting for solving for fun, but I don't know if it will be useful for FMC or speed.

 

[bobthegiraffemonkey]

What would be the alg count for ELL including both parities? 116?

Other than things like bad recognition and high alg count, this seems like it's at least worth some thought for 4x4. Yau/CFCE with the E including solution to either or both parities would guarantee a 2 look last layer.

What about OLL including OLL parity and PLL including PLL parity? Is it as simple as being twice the number of OLLs and PLLs?

I considered this worth some thought a few weeks ago and only just found this post. I started making algs but never finished the cases because I'm lazy.

Edit: I messed this up earlier, I'm a little tired I guess. I only looked at ELL when there's OLL parity, which is a total of 48 cases. I never finished making algs, might tidy up what I have and post at some point.

 

[supercavitation]

I think I have something no one has seen. I call it the Aw method or 23CCLLP5EO5EL3E but that's a little long.

I thought of this when I realized people often try to solve layer by layer up the cube but what if you solved up with the cube standing on one corner?

1. Solve 2x2x2 block. For the sake of my description, let the corner in you 2x2 be FLD. This is intuitive.

2. Solve Corners ULF, FRD, and BLD. This is intuitive.

3. Do 1 of 42 CLL algorithms, but they instead of effecting the corners on the top layer, effect the corners UFR, UBL, BRD, and UBR.

4. Do 1 of I don't know because I'm bad at math algorithms to permute and orient the edges in FR, BL, and BR.

5. Solve with slightly modified Roux.

My estimate is 5+9+11+10+15 moves which is 50.

Crossing my fingers that nobody has thought of this...

...or you could use Petrus (or Roux). The number of algs for step 4 could be quite high unless you split it into two steps, considering that there are still 7 unsolved edge slots. Additionally, one of the nicest things about L6E (the fact that it can be done just <M,U>) is lost. I can't see this catching on, except, as previously mentioned, perhaps a bit for FMC.

 

[TheNextFeliks]

Or you could just use Petrus.

 

[notfeliks]

Not a method or subset or anything, but out of curiosity, has anyone ever tried 3x3 speedsolving where the solved position is any that has all of the pieces permuted with orientation disregarded? I tried it and it seems kind of fun, but I think it would become so easy after a while that single times would become outlandishly fast and luck would play way too big a role.

 

[Renslay]

Not a method or subset or anything, but out of curiosity, has anyone ever tried 3x3 speedsolving where the solved position is any that has all of the pieces permuted with orientation disregarded? I tried it and it seems kind of fun, but I think it would become so easy after a while that single times would become outlandishly fast and luck would play way too big a role.

Recently I did something similar: I tried to "solve" the cube into the superflip position from a scrambled position. It's fun how you have to treat all the edges with their other orientation!

 

[elrog]

I think I have something no one has seen. I call it the Aw method or 23CCLLP5EO5EL3E but that's a little long.

I thought of this when I realized people often try to solve layer by layer up the cube but what if you solved up with the cube standing on one corner?

1. Solve 2x2x2 block. For the sake of my description, let the corner in you 2x2 be FLD. This is intuitive.

2. Solve Corners ULF, FRD, and BLD. This is intuitive.

3. Do 1 of 42 CLL algorithms, but they instead of effecting the corners on the top layer, effect the corners UFR, UBL, BRD, and UBR.

4. Do 1 of I don't know because I'm bad at math algorithms to permute and orient the edges in FR, BL, and BR.

5. Solve with slightly modified Roux.

My estimate is 5+9+11+10+15 moves which is 50.

Crossing my fingers that nobody has thought of this...

People usually solve 2x2x2 blocks with the BRD corner because you can see more of the cube throughout the rest of the solve and it helps with lookahead. Also, when did you solve the DR edge?

For step 4, you can easily insert these edges intuitively if you had the M layer free. I think it may be better to start off with a 1x2x3 block on the left like in Roux, then solve the ULB and DRB corners, then use an algorithm for the last 4 corners, then solve 3 edges in the right ide by inserting them, and then do LSE.

Now from this, you could make an improvement from doing CLL normally on the LL because you can AUF the last layer. There would be the same number of cases doing CLL how you proposed, but instead of doing an AUF, you would have to rotate the cube around a corner.

Also, I have had the idea I just described in my head for a while (I'll still let you claim it if you want), but I was thinking you could do RoFL CLL to improve the movecount a bit.

Recently I did something similar: I tried to "solve" the cube into the superflip position from a scrambled position. It's fun how you have to treat all the edges with their other orientation!

I have a friend who does that in blindsolving. He will memorize good edges instead of bad if there are less good than bad. At the end of the solve, he just does the superflip. Pretty neat.

 

[Michael Womack]

Hi I just want to show a video of an example solve of my 4x4 method called the B4 method. The B4 name is short for Belt method for 4x4. Also sorry for some parts of the solve to be out of frame. The scramble I used was R B2 F' u2 B' f2 u f2 R' r2 f' L2 r2 F' L' U u L2 u2 U B U2 f2 D L2 R' B2 L' F U B r U' u f' F r2 R2 u B'. This method could be potentially use for speed solving if we all look at better algs for the this method. This method consists of 8 steps:
Step 1: solve 2 opposite centers
Step 2: solve 2 more opposite centers
Step 3: solve the edges that connect the 4 solved centers together
Step 4: Solve the remaining 2 centers
Step 5: orient the corners. In this step there is a parity where you get on unoriented corner in the U and D layer but in the solve I did I got lucky by not getting it.
Step 6: place corners into the correct layer
Step 7: position the corners into the correct spot
Step 8: solve remaining edges

 

[TheOneOnTheLeft]

You could swap steps 2 and 3 so that you solve the belt edges similarly to Yau's first 3 cross edges. Should be more efficient and if you place them before solving the rest of the centres, then making the other centres can also be done as fast as Yau, except using slice moves instead of wide moves.

 

[Michael Womack]

You could swap steps 2 and 3 so that you solve the belt edges similarly to Yau's first 3 cross edges. Should be more efficient and if you place them before solving the rest of the centres, then making the other centres can also be done as fast as Yau, except using slice moves instead of wide moves.

This is true I could do that.

 

[elrog]

Cubeshape last example solve

(3,-1) / (0,1) / (-3,6) / (2,1) / (-2,-3) / (2,6) / (0,6) / (-2,-1) / (-4,2) / (-2,6) / (1,2) / (-1,0) / (0,-3) / (-2,5) / (-2,-3) /

edge deisolation:

6,2 / -5,4 / -3,-2 / 0,2 / 1,0

corner orbit resolution (+ reaching selected pairing state)

/ 2,0 / 0,-2 / 4,-2 / 4,0 /

edge pairing (stage needs most improvement)

parity
/ 2,-4 / -2,4 /
easy
4,1 / 1,1 / 1,-1 / -1,-1 /
2-2 cycle
-3,4 / -4,3 / 1,0 / 1,0 /
3 cycle
-1,6 /
1,0 / 5,-1 / 1,0 / -1,0 / 0,1 / -5,0 / -1,0

mini domino esque 2x2x1 pbl

/ -3,0 / 3,-3 / 6,0 / -1,-5

Nobody made a comment :confused:.

I personally am curious as to what your trying to show us. It looks like square 1 scramble, but I really have no idea as I don't have one.
------------------------------------------------------------------------------------------------------------------------------
Here's an idea I came up with and have been using for the last couple of days.

Method
- Make a block on the left the same as in the Roux method
- Solve any M layer edge and AML (Adjust M Layer) so that the edge is in the DB or DF position (preferably DB for lookahead)
- Build a 1x2x2 block on the right side. This block does not need to match up with the left block or the M layer edge
- Extend the 1x2x2 block on the right side into a 1x2x3
- Place another M layer edge and AML so that all pieces in the F2L are solved
- Do a NMLL of your choice

There is a NMLL algorithm set out there (you can find it on the wiki), but it only covers cases with all edges oriented.

One option for the LL is CPEOLL and 2GLL. The biggest drawback for this would be the recognition. The EO in CPEOLL can be recognized by first finding the orientation of the UL and UR edges by finding the L and R edge colors followed by looking at the remaining two edges to see if they have the U center color on top. 2GLL can be recognized by the orientation case of the corners using the L and R colors and pairing that with the placement of the L and R stickers on the edges.

I have come up with another NMLL. The biggest drawback to this is its algorithm count. It is inspired by the one on the wiki. Its algorithm counts would be 82 for the first step and 30 (maybe less if I check for mirrors) for the second. The first step is the same as the normal NMLL, except you force one of the UL and UR edges to be oriented while the other in misoriented. For each normal case you have 2 algorithms. One will either flip both the UL and the UR edges or leave them both oriented how they are. The other will flip one of the UL or UR edges but not the other. You then can finish with a step similar to the regular NMLL, but it will flip the misoriented Ur or UL edge and an M layer edge. You should know which M layer edge your algorithm flips and AML so that your misoriented edge is in the correct place.

Personally, I think poor recognition is worse than more algs, so I'd go with the second option listed here. I played around with a lot of things, but these were the only 2 LL systems that seemed viable. Enjoy!

Oh, and btw, what should I call this? NMM which stands for Non-Matching Method? Or just simply Method as I have done in this post?

 

[kcl]

Whether you call it a T perm or not, the adjacent swap alg I use is R' U R' F2 R F' R' F2 R2. Is R' U R' F2 R F' U R' F2 R F' R really "much slower" than that? I'll take that over CP recognition any day.

Yes, I'm not sure you realize how fast CP recognition is for those of us who use it frequently. Learn a CLL set and you'll understand.

 

[mark49152]

Yes, I'm not sure you realize how fast CP recognition is for those of us who use it frequently. Learn a CLL set and you'll understand.

Did you even read the original proposal?

 

[Dane man]

Well, I was thinking, and a very interesting method came to mind. It reduces the cube to <R, U, F2>, and solves the cube from there. Because it begins very similar to Petrus, I'd like to call it Pet rock. Here's the idea.

1- Solve the 2x2x2 block in the BDL corner.
2- Orient the edges relative to <R, U, L, D>. The freedom of having a third side to turn without restriction should make this simpler to perform.
3- Extend from the original the 2x2x2 block to a 2x2x3 on the F side. This is done only using <R, U, F2>. With practice, this could become very efficient.
4- Extend from the original 2x2x2 block to a 2x2x3 on the R side. This in combination with step 3 should leave an F2L slot and all the edges oriented. (Use only <R, U> moves)
5- Insert the last F2L edge/corner pair (the orientation of the corner doesn't matter, allowing faster execution). (Use only <R, U> moves. 25 cases. Avg moves 7.5, rare worst case 12)
6- Perform CLS (24 algs (CLS: I/CLS: I(mirror)/OCLL). This orients the rest of the corners and leaves the edges oriented, skipping OLL)
7- Perform PLL. Done!

Because of the nature of the method, I don't have any way of discovering the avg move count besides actually performing it myself multiple times, so I have no idea how efficient it is yet, but what I do know is that it is very intuitive until steps 6 and 7. The total alg count is 55.

The combination of CLS and PLL has an avg move count of 22.3 (compared to the OLL/PLL avg move count of 21.5). Now the question is what the average moves are for steps 1-5. From what I've tested already, it seems not to be much more than what is already common for Cross+F2L or Petrus->F2L, though I'd like to test more, and see the possible situations.

It really depends on if steps 2-4 require less moves on average than 3 F2L slots. If I were good at block building, I could probably find out. Step 2 should be quick, though steps 3 and 4 will likely take more. Anyone already know or willing to give it a go?

What do you all think?


Moves required in step 5 cases

Spoiler

1/25 = 0 (done)
2/25 = 3 (connected correctly on top)
2/25 = 4

1/25 = 7 (disconnected left)
3/25 = 8

1/25 = 7 (disconnected right)
3/25 = 8

1/25 = 7 (edge in, corner on top)
3/25 = 8

1/25 = 7 (corner in, edge on top)
3/25 = 8

2/25 = 11 (connected incorrectly on top)
2/25 = 12

 

[Renslay]

Well, I was thinking, and a very interesting method came to mind. It reduces the cube to <R, U, F2>, and solves the cube from there. Because it begins very similar to Petrus, I'd like to call it Pet rock. Here's the idea.

1- Solve the 2x2x2 block in the BDL corner.
2- Orient the edges relative to <R, U, L, D>. The freedom of having a third side to turn without restriction should make this simpler to perform.
3- Extend from the original the 2x2x2 block to a 2x2x3 on the F side. This is done only using <R, U, F2>. With practice, this could become very efficient.
4- Extend from the original 2x2x2 block to a 2x2x3 on the R side. This in combination with step 3 should leave an F2L slot and all the edges oriented. (Use only <R, U> moves)
5- Insert the last F2L edge/corner pair (the orientation of the corner doesn't matter, allowing faster execution). (Use only <R, U> moves. 25 cases. Avg moves 7.5, rare worst case 12)
6- Perform CLS (24 algs (CLS: I/CLS: I(mirror)/OCLL). This orients the rest of the corners and leaves the edges oriented, skipping OLL)
7- Perform PLL. Done!

Swap step 2 and 3 and you have Petrus.
http://www.speedsolving.com/wiki/in..._you_could_just_use_petrus_.28July.2C_2009.29 = "Or you could just use Petrus."