The New Method / Substep / Concept Idea Thread

[IAmAPerson]

Sorry about all of the weird method ideas. I get bored (probably should memorize algs instead of pointless methods). Anyway, I don't do blindsolving. I know about Old Pochmann, M2, memo techniques, etc. but I don't do blindsolving. However, I still find it interesting. I had an idea for corner solving (probably crap, but oh well). It's similar to EG, but does it without affecting edges.

Method:
Use algorithms to make a side.
Use an algorithm to solve the rest.

Example solve

Pros:
No "memorization" needed.
Great for MBLD since no real memorization is needed.
Quick to see corner solving.
Can be 100% <R,U,D> 3-gen (my favourite type of 3-gen). However, I used some <M,U> 2-gen in the solve because it was better for that alg.

Cons:
Lots of algorithms.
Long/awkward algorithms.
An algorithm must be used for any turn while making a "side". (i.e. To make an "F' " turn without messing up the edges, the alg "R D2 R2 U2 R2 U R U' R U R U R2 D2 R' " must be used.)
Long movecount

Probably been thought of before, and probably junk, but here it is.

 

[Mohammadahmadi]

New Method! (Generalization of EG in 3x3)

Hi. this method going to be so faster than Jessica method (if its true). As you know EG is a fantastic method in 2x2 solving (In this method we make one face and then solve the cube with one of 120 EG algorithms).
I was thinking about that why we don't do same in 3x3? of course 3x3 is difference and we are going to face some problems in this way.
I'm writing to say my idea about this generalization and hear your ideas to make it better.

First stage:
we make cross on one side. (just make cross. we don't care about permutation)


Second stage:
Use F2L algorithms (Jessica method) to make 2 layer but with a difference, in this case we don't care about corner permutation. corner orientation matter. edge orientation and permutation matter.


Third stage:
Use one of 120 NEG algorithms (NEG = New EG. These algorithms do not exist yet but we use them in this method) to make first layer corners permutation and third layer corners orientation and permutation (just like EG in 2x2).


Last stage:
Use one of 125 (25x5) NELL algorithms (NELL = New ELL. These algorithms do not exist yet but we use them in this method) to make first layer edges permutation and third layer edges orientation and permutation (just like EG in 2x2). so cube is solved.


Lets compare this method with Jessica's method:
1. in Jessica method we make cross. but edges permutation matter. in this method we make cross easier and faster because we don't care about edges permutation.
2. in Jessica method we do F2L. but corner permutation matter. in this method we make first 2 layer faster and easier because we don' care about corner permutation so we can match each edge with one one 4 corners.
3. in Jessica method we do OLL and PLL. here we do two another algorithms (NEG and NELL) just like Jessica method. but i think these new algorithms going to be faster than OLLs and PLLs. why? you can just compare this with EG method in 2x2. EG algorithms are faster than CLLs. so here we have same.

please feel free to ask your questions and say your ideas.

 

[Stewy]

the cross: although it may be faster to build the cross regardless of permutation, i'd say it's a negligible difference

f2l: yes, f2l by itself for this step would take less moves and less time with this method

NEG or whatever: not only would algs have to be generated, but they would be of a higher movecount, and recognition would be much slower than OLL

NELL or whatever: once again, algs would have to be generated, the movecount would be higher and recognition would be slower

but i think these new algorithms going to be faster than OLLs and PLLs.

they would never be faster than OLL and PLL

why? you can just compare this with EG method in 2x2. EG algorithms are faster than CLLs. so here we have same.

no, that's not how things work.


also this belongs in the "New Method / Substep / Concept Idea Thread", but i suppose it's up to a moderator to move it

 

[cashis]

or you could just use petrus
in all seriousness , I cant see this being better than " Jessica method". It's good thoughts, but is it really applicable?
I cant see recognition for any of those stages being easy, and there's a lot of algorithms. (120+125=245=half of zbll??)

 

[qqwref]

You're talking about CFOP, right? People call it Fridrich, but nobody calls it Jessica method.

I don't think this method has much potential, except as something to do for fun (but then again, it has soooo many algs). My reasoning is as follows:
- F2L is pretty efficient and fast already, so I'm not sure you would save much time solving it this way. Maybe you could keep track of blocks, but it would certainly be confusing. Pairing up a corner and edge that are a D move off is already kind of tricky.
- Unlike in CFOP, where more and more of the cube is solved (and can be ignored), in this method you would have to keep track of the bottom layer, either by looking at it or by remembering the position. That is generally slower and more difficult.
- Algorithms that move pieces around on the bottom layer are generally not going to be very fingertrick friendly. There might be a few nice cases, but most will be long, or have lots of half turns, or will involve many turns of things other than F/R/U. This will especially be true for ELL + D edge permutation, which will almost certainly have lots of M and S moves. Try generating a few algs and you will see what I mean.
- Just as a side note, there are not 5 cases for bottom layer edge permutation, but (I think) 11.

It's worth mentioning that the big strength of EG on 2x2x2 is not how great the algs are, but rather how easy it is to one-look. Because a face is so short, a good solver can usually look ahead during inspection to figure out what alg they will get, and then they can do the entire solve in one sequence of moves without having to figure out what to do. That advantage isn't present here, so instead you are just solving something incorrectly and fixing it later, without a good rationale for it.

 

[Mohammadahmadi]

the cross: although it may be faster to build the cross regardless of permutation, i'd say it's a negligible difference

anyway its faster

they would never be faster than OLL and PLL

are u sure? give me a reason. anyway i have one reason
In CLL we move up corners. in EG we move up and down corners togather. so we are more free ("we save some moves" as Stephan Pochmann said)
In this method (just like EG and CLL) we move up and down togather. so we are more free. so it may be faster (just maybe. its only a reason. not proved)

 

[cashis]

anyway its faster


are u sure? give me a reason. anyway i have one reason
In CLL we move up corners. in EG we move up and down corners togather. so we are more free ("we save some moves" as Stephan Pochmann said)
In this method (just like EG and CLL) we move up and down togather. so we are more free. so it may be faster (just maybe. its only a reason. not proved)

hmm read qqwref's post.
recognition would be not good
algs would also be not good

 

[Mohammadahmadi]

I cant see recognition for any of those stages being easy

recognition is just like EG

and there's a lot of algorithms. (120+125=245=half of zbll??)

yes it is. its double jessica method. i will learn if its faster

 

[cashis]

Please just read qq's post.

 

[Mohammadahmadi]

You're talking about CFOP, right? People call it Fridrich, but nobody calls it Jessica method

u right.

F2L is pretty efficient and fast already, so I'm not sure you would save much time solving it this way. Maybe you could keep track of blocks, but it would certainly be confusing. Pairing up a corner and edge that are a D move off is already kind of tricky.

we have 4 steps in CFOP. i think F2L is longest step. so i was thinking to make it shorter

Just as a side note, there are not 5 cases for bottom layer edge permutation, but (I think) 11

yes. it is. we may fix it (if necessary)

Try generating a few algs and you will see what I mean

that's only way to find out?

 

[supercavitation]

that's only way to find out?

Here, have a random 3x3 EG, pulled from earlier in this thread:

R' U' R D R D' R D R U2 R D' R' U' R' U' R2

That's 17 moves, and the fingertricks on it are awful, even with one of the best turning subsets in use.
Once again, read qq's explanation as to why the EGs won't be shorter on 3x3. 3x3 EG has been proposed before, and there's a very good reason why no one uses it.

Also, point of clarification 78*3=234, while this would (even assuming your incorrect permutation count is accurate) take 245. This is more than 3 times as many algs as CFOP for a very definite disadvantage.

 

[Mohammadahmadi]

i was trying to generate some algs. but i cant do that with Cube Explorer.
i need some algs like this. corners have a EG style. down edges orientation is fix but they can permute with each other. second layer edges are fix. up layer edges can permute and rotation
please say me how can i generate some of these algs? any other software u know?

 

[supercavitation]

i was trying to generate some algs. but i cant do that with Cube Explorer.
i need some algs like this. corners have a EG style. down edges orientation is fix but they can permute with each other. second layer edges are fix. up layer edges can permute and rotation
please say me how can i generate some of these algs? any other software u know?

I usually use Cube Explorer if I don't care if the alg is finger tricky (if you're doing 3x3 EG, you clearly don't), and ACube if I do. Neither will give you good algs for terrible cases, though, so prepare for disappointment. Not an insult, simply advice I wish someone had given me way back when.

 

[Mohammadahmadi]

Just as a side note, there are not 5 cases for bottom layer edge permutation, but (I think) 11

how do u say that's 11 cases? ofcorce its 4+1 cases (4 PLL and one solved face)

 

[willtri4]

how do u say that's 11 cases? ofcorce its 4+1 cases (4 PLL and one solved face)

You could have an odd permutation. That adds adjacent swap, opposite swap, cw O perm, ccw O perm, and W perm.

 

[Mohammadahmadi]

You could have an odd permutation. That adds adjacent swap, opposite swap, cw O perm, ccw O perm, and W perm.

we can just fix it with doing some D

Hi. this method going to be so faster than Jessica method (if its true). As you know EG is a fantastic method in 2x2 solving (In this method we make one face and then solve the cube with one of 120 EG algorithms).
I was thinking about that why we don't do same in 3x3? of course 3x3 is difference and we are going to face some problems in this way.
I'm writing to say my idea about this generalization and hear your ideas to make it better.

First stage:
we make cross on one side. (just make cross. we don't care about permutation)
View attachment 5292

Second stage:
Use F2L algorithms (Jessica method) to make 2 layer but with a difference, in this case we don't care about corner permutation. corner orientation matter. edge orientation and permutation matter.
View attachment 5293

Third stage:
Use one of 120 NEG algorithms (NEG = New EG. These algorithms do not exist yet but we use them in this method) to make first layer corners permutation and third layer corners orientation and permutation (just like EG in 2x2).
View attachment 5294

Last stage:
Use one of 125 (25x5) NELL algorithms (NELL = New ELL. These algorithms do not exist yet but we use them in this method) to make first layer edges permutation and third layer edges orientation and permutation (just like EG in 2x2). so cube is solved.


Lets compare this method with Jessica's method:
1. in Jessica method we make cross. but edges permutation matter. in this method we make cross easier and faster because we don't care about edges permutation.
2. in Jessica method we do F2L. but corner permutation matter. in this method we make first 2 layer faster and easier because we don' care about corner permutation so we can match each edge with one one 4 corners.
3. in Jessica method we do OLL and PLL. here we do two another algorithms (NEG and NELL) just like Jessica method. but i think these new algorithms going to be faster than OLLs and PLLs. why? you can just compare this with EG method in 2x2. EG algorithms are faster than CLLs. so here we have same.

please feel free to ask your questions and say your ideas.

after some talking and thinking i understood that this method have following problems.

1. number of cases are high
its 125+120 algs. anyway its possible to learn (down layer have 5 cases not 11. we can change them just with doing some D)
2. algorithms are hard and long
they are going to be somethings like ELL and CLL algs. NELL algs will have so many M just like ELL. and NEG are like CLL (as i checked some cases)
3. recognization is hard
yes it is. the on way to make is better is to memorize 4 corners
4. sometimes we face error! just do M2 U2 M2 U2 to see what i say. so we have 2 way.
---1- memorize 2x125 except of 125 (Approximate)
---2- fix error with doing M2 U2 M2

 

[shadowslice e]

Step 3) orient all corners
I usually do this by orienting four corners first then bringing them to the bottom and then using roux algs for the top layer. This step can probably be made more efficient by using an alg that does a sune on the top and a sune on the bottom and then repeating or altering some of the orientation algs on a 2x2 and making them e-slice safe. This would create a new set of algs. However, this could be quite a large alg set.

UPDATE: I found this very helpful post on Ryan heise's website that helps with the corners; "Now for the corners, we can twist two corners at a time. Start with one
corner at LUF (corner A) and the other corner at FDR (corner B). Then
do:

R'D - twists the B corner
L2 - swaps the B and A corners
D'R - twists the A corner on the way back

Do this repeatedly until all corners are twisted the right way" this could be used either as suggested or be done to correct corner parity.

Generated basic algs for this step. Move count ~23 for all methods of doing this step. that I've looked into.
Total move count for method so far ~45-55

Also finally came up with reasons for this method- more efficient that CFOP (and less alg heavy than either CFOP or ZZ), less intuition than Roux or Petrus (so fast turners will be more able to use it while still using the visually awesome LSE finish) and in addition also quite ergonomic.

 

[shadowslice e]

Alternative method using the same principle as my previous method: 3SSE

So, same basic steps:

1) permute 3 e-slice pieces in relation to each other ~5 moves, 0 algs
2) orient 3 corners- any 3. It doesn't matter as long as they are in the d-layer ~5 moves, 0-3 algs
3) "pair" a corner with the remaining e-slice edge (make sure it is in the U layer) ~3 moves, 0 algs
4) Winter Variation- ~8 moves, 27 algs (the algs could be even shorter on average as there is no full F2L-1 to preserve.
5) Bring corners to correct layers- ~3 moves, 0-3 algs
6) permute all corners. Use algs for square one- ~7 moves, 5 algs
7)Insert rd and ld edges- ~6 moves, 0 algs.
8) LSE, ~13 moves, 0-2 algs.
Any extra setup moves- ~2 moves, 0 algs

Total for method- ~48 moves, min 32 algs (but 48 is still probably quite achievable with only 32)

Please feel free to pick this apart for all the flaws

 

[KRAMIST]

1) Solve corners and edges of first layer (for me white)
2) Use CMLL to orient next layer ( Yellow)
3) Use M2, BH,TuRBo for edges

i don't have an example solve too lazy

 

[shadowslice e]

1) Solve corners and edges of first layer (for me white)
2) Use CMLL to orient next layer ( Yellow)
3) Use M2, BH,TuRBo for edges

i don't have an example solve too lazy

 [https://www.speedsolving.com/wiki/index.php?title=Waterman_method&redirect=no]

Waterman