SpeedSolving.com Puzzle Forum - Constructive Speedcubing Discussion

How Common is Colour Neutrality?

gundershot — Tue, 14 May 2013 10:33:35 GMT

I was always under the impression that being colour neutral was a normal thing, I was able to master colour neutrality in about 2 weeks. After some searching about colour neutrality, it seems to me that most people can only start on white. Is colour neutrality really that uncommon?

Noah's CP Block Method 2.0

Noahaha — Tue, 14 May 2013 05:22:12 GMT

As some of you may remember, I proposed a Petrus based CP-block method a while back. The problem with it was that it made Petrus even more inefficient than it already was just in order to have a 1LLL.

I never dropped the idea of CP-blocks, however...

...and today I bring you my NEW AND IMPROVED CP-block method. Unlike the last one, it is its own method. It shares characteristics with Petrus, Roux and OBLBL, but the end result is definitely something entirely different and hopefully new. I say hopefully, because all "new" methods must come with the disclaimer that someone may have discovered them before.

Onto the method:

Step 1: CP (Roux) Block

The goal of this step is to reach a state where there is a Roux block solved on the left and the corners are permuted.

It can be divided into three parts:

1a - SOLVE A ROUX BLOCK on the left (note that you can mirror the entire method) just like the first step of Roux. I recommend doing the same block every time.

1b - PLACE, but do NOT orient the FDR and BDR corners. This should take 4 moves at most.

1c - CP.

Recognition: figure out which two U-layer corners need to be swapped.
If no corners need to be swapped, you're done!
If two adjacent corners need to be swapped, place them at UFR and UBR, and do F' U F or y R U' R' y'.
If two diagonal corners need to be swapped, make them adjacent and then do what's above.

Cases:
- UFL UFR = F' U' F
- UFR UBR = F' U F
- UBR UBL = F' U2 F
- UBR UFL = U' F' U' F
- UFL UBR = R' F' U' F
- UBL UFR = R F' U2 F

Ideally, 1a and 1b would both be planned in inspection, or at the very least the positions of the last two D-layer corners would be noted.

Step 2: EDGES!

This step has two parts, although ideally they should merge into one step. Step 2 is where this method has a LOT of freedom.

Step 2 brings the cube to a state where the bottom left 2x2x3 is solved, the edges are oriented and the corners are permuted. As long as you only use U, R and r moves during this step, the corners will remain permuted from the CP-block.

2a - ORIENT ALL EDGES

I haven't found a way to break this down yet, so people who are not familiar with Roux might struggle a little bit here. A Roux approach seems best to me, using moves like M' U M to orient 4 edges at a time. If you have two edges left, just put them at UB and UL and do M' U M U2 M' U M. Note that an M/M' move changes the orientation of all edges on the M-slice. You should start by placing your U/D centers into place or opposite places because in the end you have to have them oriented along with the edges.

As qq pointed out, there are 5-move 2-flips:
DR and UF: r U R U' r'
FR and UF: M' U R U' r'
etc. they all follow the trend of slice, replace an edge, slice back.

2b - FINISH THE 2x2x3 by placing the DF and DB edges.

This is extremely easy and should only require 3-6 moves depending on where your edges are at the end of 2a. A good strategy is to connect them at UL and UR, and then insert them between the correct two centers. Remember, you can only do double turns involving the M-slice in order to preserve EO, so other than M U2 M' type things, the moves you can make are: R, R2, R', M2 and r2.

NOTE: you can start step 3 before finishing 2a if it's convenient.

Step 3: Right Block

This is the same as the right block in ZZ and step 4 of Petrus. Just use R and U to finish F2L.

Step 4: 2GLL

Yay! We have finally reached our 1LLL, and it only requires 85 algs. That's not much more than CFOP :)

Summary

Step 1 - CP block
-1a = Roux Block
-1b = Place last two D-layer corners
-1c = CP in 0, 3, or 4 moves
Step 2 - EDGES
-2a = EO
-2b = Finish Petrus Block
Step 3 - Right Block
Step 4 - 2GLL

Analysis

Pros:
- REALLY fingertrick friendly (only uses M, U, R and r after step 1)
- Practically rotationless
- Many substeps can be solved in very few moves
- 1LLL
- Lots of freedom
- It's really fun!!!

Cons:
- A lot needs to be planned in inspection
- Lots of sub-steps
- Potentially really high movecount
- 85 algs to learn
- Although there are often really quick solutions, they are not always easy to see in a speedsolve.

Feel free to give me more pros and cons to add :)

Example Solve

Scramble (in solving orientation): B2 U2 L2 R2 D' R2 D' B2 D' B2 U2 L B F2 L2 D' L' F2 R' D F2

1a: U2 L' U L2 D F U' L2 (8)
1b: U' R' U R (4)
1c: U2 B U' B' (4)
2a: R' U2 M' U M (5)
2b: R2 U' r' U2 r (5)
3: R U2 R' U2 R' U R U2 R' U R (11)
4: U2 R' U R' U' R' U' R' U R U R2 (12)

Move count: 49

Conclusion

I don't think anyone will end up using this to speedsolve because it is pretty complicated, but I hope people enjoy the method and use it for fun sometimes. If you like it, please post an example solve. A lot of the fun of this method is finding shortcuts and ways to accomplish two things at once.

Sorry for the long read, and sorry if this has been thought of already!

Solving Methods; A Primer

Kirjava — Thu, 09 May 2013 15:29:11 GMT

This thread will attempt to give an extensive introduction to
properties different methods have. I will also give my thoughts on
each.

As well as people developing methods or considering new techniques, I
hope this may help the way you perform or think about regular
speedsolving.

Basics

Solving methods consist of any number of steps which contain
instructions detailing how to bring the cube from one state to
another. In 'good' methods, each step will attempt to take maximum
advantage of the state of the cube. This makes analysis of first steps
quite interesting - with so much freedom it makes sense that no
specific step seems to be much more useful than alternatives. A step
may accomplish more than one thing at once.

Method definitions often break up one step into many smaller,
systematic, and human sized chunks. These chunks are essentially part
of the same step. "blockbuild stuff" then "blockbuild more stuff"
becomes "blockbuild a lot of stuff". It can be advantageous for a
human to be aware of these abstractions and ignore them.

On the point of steps starting to blend into each other, it's worth
noting that it's difficult to exactly define the term 'method'. Minor
variations give rise to different, yet closely related systems.
Classifying these systems as completely new methods feels needless,
yet it is difficult to draw a line.

Something that seems unpopular these days is a 'multi-system' (as
described by Singmaster). This is where a method will 'fork' at a
certain step and finish in different ways depending on the direction
forked. The direction chosen to fork in is based on which can take the
best advantage of the current situation, but either can be chosen if
desired. Examples of this technique can be demonstrated by creating
hybrid methods which will allow forking between the two at certain
stages. Multiple forks in the same method are not feasible/sensible
imo. This idea can be seen when using separate algs for special cases
to achieve more than the original intention of the step.

This is closely related to being 'method neutral' - being closely
proficient enough at multiple methods to allow you to choose the
method when starting the solve based on the scramble. The difficulty
in obtaining this skill for the solver requires either to initially
learn two methods at once and practise both, or to practise one method
and at a later date attempt to practise another and bring it up to the
proficiency of the first. The problems with the latter technique are
similar to that of switching to colour neutral.

Step method order may not be fixed. Methods designed for blindsolving
can have this attribute - because of the nature of the method, where
each algorithm (mostly) leaves the rest of the cube alone, the order
is less important and changing it can be trivial.

Solving Types

In this section, I will analyse the types of technique used to
complete a step. This can mean two different things (that have their
own categories) - the human approach to completing the step and what
type of state change has taken place during the step.

There are a few systems that humans use to accomplish steps. The most
apparent one being the algorithmic approach to something. Called "the
worst thing in speedcubing" by Gilles Roux, this system enumerates the
cases in a given step and lists solutions for each. The solver will
then learn a solution for each case so that when it appears in a solve
they can recognise and recall the solution from memory.

An algorithmic approach can be used in steps that are traditionally
seen as intuitive based, but this is not generally advised - it
usually entails using some basic tricks or rules to reach a state that
you have an algorithm for. This is seen to generally lead to longer
solutions, but that does not make it worse.

An intuitive approach to solving a case is arrived at by logic and
reasoning that has been generated by experimentation. I think the
ability to use intuition to generate solutions for something is
important - it demonstrates awareness of the effect caused by applying
moves which is an important trait in understanding the cube and
shortcuts available. In comparison to algorithmic approaches, a
solution for each case is discovered by the user using logic or trial
and error. Cases may be improved over time as the solver's ability to
intuit more efficient solutions improves.

Many steps can be approached in either an algorithmic or intuitive
way, but some may require either one of the other to be used.
Something of note is that after a while, whichever approach you take
appears to converge towards the other. That is to say that intuitive
approaches to cases begin to become second nature and are executed in
the same manner as algorithms, while the solver can gather an
understanding of how an algorithm works the more familiar he is with
it. In situations where either approach can be used, the labels
intuitive/algorithmic describe the learning process - as the end
result is essentially the same.

A learning system that doesn't quite fit into either category is a
rule based one. This consists of specific things to perform for one
of many cases. There will be different groups of cases that require
the same thing to be performed to advance to the next part - which
will either be another case from a category, or completion of the
step. Examples of this are the edge orientation step from the Roux
method, dual alg single step systems for LL (Petrus 270, OLLCP hax),
or some cubeshape systems for Square-1. I like to call these systems
'flowcharting systems' as the data can be expressed as a flowchart.

Another rule based system involves using a formula to generate move
sequences. The only examples I can think of that do this are
commutators and conjugates. This involves using a formula to create an
algorithm to perform a certain task. While intuition is required to
create the different parts of the formula, the structure of the
algorithm created is predefined. This appears to result in a system
that allows creation of predictable results that can be used
'on the fly' without premeditative learning.

As with other systems, these will eventually become algorithmic *and*
intuitive.

There are two different state changes that a step can accomplish.

Direct solving is the most prevalent and *has* to feature in a method
at some point for a cube to be solved. With this technique, pieces
dictated by the step are fully permuted and oriented. With respect to
a given reference. This does not have to be an external reference
point, and does neither have to be the same reference point as in
previous steps (pseudoblocks).

Quoting Quadrescence: "I think if you are directly solving, you have
an absolute reference point throughout the process". While this
contradicts what I am saying, I see it as a perfectly valid view on
what constitutes direct solving. This is a good example of the grey
area seen when describing these concepts, which I have had trouble
with when writing this article.

Reduction is not a requirement for a method, but can be a powerful way
to bring a cube closer to solved. When a step involves a reduction,
there is a subset of states that the cube is required to be in for
completion of the step. The step after will only deal with solving
those states, so removal of others facilitates completion of the step.
This also further reduces the number of states a cube can be in,
bringing it closer to solved. While this is also true for direct
solving, the required states do not require pieces to be permuted or
oriented correctly. Certain attributes can instead be enforced that
involve *only* permutation or orientation, or pieces to be grouped in
certain ways.

Some steps contain a mixture of both types, like direct solving some
pieces and reducing others.

Pseudo solving is an interesting quirk. This entails solving to a
state whereupon after normal conclusion of the method, extra moves
will be required to resolve the pseudo creation. So instead of solving
to a solved cube state, you are solving to the state of one (or more)
moves away and then adding those moves at the end. This can be
advantageous because pseudoblocks may be easier to create than the
normal blocks required.

A pseudo move can be applied over the course of a few steps and can be
used with either direct solving or reduction.

Method Feasibility

Unfortunately, most metrics for measuring method feasibility cannot be
quantified easily. Along with personal preference, this makes
comparing different systems a mostly subjective ordeal.

A major aspect of what constitutes a good method is the movecount.
While this is not the quintessential element in deciding how well a
method will perform, it is a purely quantifiable attribute that gives
a good indication. All major speedcubing methods in use have a similar
movecount, with ones giving a higher movecount providing advantages in
other areas.

Because of the human element to speedsolving, ease of use is another
key factor. Methods that are without complication tend to fare better
as they are more attractive to learn and receive more testing. While
more complicated methods may perform better in the long run,
demonstrating this fact proves difficult when no one desires to try.

Methods with complicated steps also require extra thinking time, which
should not be present when speedsolving. A disadvantage in many
methods with low movecounts is the thinking time required to execute
certain steps.

Another ease of use issue is the required learning overhead. This
usually means the quantity of algorithms required to be learnt in
order to fully utilise a method. Methods with less algorithms tend to
rely on using more steps and intuition, leaving a less efficient
overall solve, while methods with algorithms numbering into the
hundreds give a steep learning curve and difficult implementation.

After initial learning of a large algorithm set, this difficulty
results from the trouble caused by attempting to recall an algorithm
from such a large subset without thinking time. While recognition of a
case from a large subset is also an issue, it is not as significant as
recall. So far, no one has been able to show proficiency with an
algorithm set numbering in the hundreds matching that of lower sizes.

As for the algorithms themselves, subsets requiring algorithms do not
usually restrict to a certain movegroup - so users can find different
to suit their preferences as they please. However, more intuition
based steps tend to lend themselves to being executed with certain
movegroups. Steps with fingertrick friendly movegroups generally fare
better than others - but this aspect is largely affected by personal
preference.

Extensions & Variations

Each base method can have countless variations and extensions.
Usually, a step or group of steps can be accomplished with multiple
systems that are of seemingly near equal feasibility. There are almost
endless combinations of alternative approaches to things.

Forced step concatenation is a popular idea for extending a method.
This involves learning how to solve two steps at once, usually
resulting in a huge increase of things to learn. When creating a
method, this should be performed on each couple of steps to ensure
maximum efficiency is produced. However, this is not always humanly
feasible to do.

A similar idea is to solve only part of the next step instead. This
gives you a subset of cases for the next step. The intention would be
to make this subset of cases be nicer than the larger set is. It's
debatable if the time saved by having better cases is negated by
getting to that subset in the first place.

Another use for partial concatenation is to reduce the number of cases
enough so that full step concatenation can take place with the reduced
step and the step after that.

Alongside different variations, systems exist that only apply in
certain situations. While these systems provide advantages in these
situations, they are not useful for every cube configuration and are
not considered complete systems. While learning tricks for magical
special cases will usually be advantagous, implementing them in solves
can introduce recognition or recall issues. Tricks like these usually
entail forcing skips of some kind.

New Method Development

People creating methods solely for entertainment purposes can skip
this section (and indeed the entire thread).

Researching existing methods is extremely important to the development
of your own. Not only will this cause you not to regurgitate methods
that we have seen over and over again, it will give you ideas of your
own. You will be able to see what works and what does not work as you
can see what is popular and used to attain good results already.

Most techniques have remained largely unexplored due to the difficulty
of testing new ideas. Do not discount them simply because they are not
popular - there are good examples of systems with low usage going to
achieve better results than their popular counterparts. Bearing this
in mind however, you should learn to be able to judge if a system has
outright bad attributes that make it undesireable for use. Bearing
that in mind, consider that your judgement may be wrong :)

Alternatives to existing steps are a good place to start, as these
currently have the highest opportunity for producting completely
viable results. This doesn't give a very interesting outcome though as
the alternative will often be similar results wise as the existing
system, with less documentation and use.

These days it seems that most trivial and obvious full methods for
well known puzzles have been completely covered. Creating brand new
ideas or improving existing ones seems to have to rely on really
abstract concepts.

You should be aware that most of your ideas will not work or will be
unsuitable for speedsolving. Be prepared to let go of an idea if it is
bad - remaining objective is key.

TL;DR METHODS!!!!!!11

Megaminx Slice Solve

TheGrayCuber — Sat, 06 Apr 2013 00:41:29 GMT

I've solved a 3x3 many times by only scrambling and solving with the slices, and it is extremely easy. A non-cuber could do it. I tried this on a 5x5, and it took a little while to figure out a solution, but eventually, it was quite easy to do. I tried to do this with a megaminx, but it is very difficult. Unlike cubes, it it much harder than a normal solve. The cube looks completely scrambled. The only difference between this and a normally scrambled megaminx is that a piece will always be opposite from the piece that it is opposite from when the cube is solved. It took me a few days to find a solution, creating algs that would work and testing a few different methods, and finally, i was able to find a method. It is quite slow, taking me around an hour, but it works. Has anybody else ever tried to do this? It is nowhere as easy as it would seem. If you think it's not hard, try it for yourself.

How to properly tension a speedcube,reduce lock ups and pops, and more.

supercubejunky — Sun, 17 Mar 2013 21:20:21 GMT

Yeh. I know it’s a bold title but this is what I’ve found out. About a month ago I was having a lot of problems with my cubes popping locking up and some issues

with speed. I kept noticing that the majority of my pops were occurring on one side and it finally dawned on me why. Even though when I had tensioned my cube

I turned all the sides evenly, the tensions hadn’t came out even! So I wondered how I could get all my tensions down to an precise and accurate measurements.

After some thought I realized that there is already a tool out there just for the job called a gap gauge/feeler blade gauge. When I bought one I was wondering

how exactly it would work out but when I put it to the test it did exactly as I had thought. I was able to get my cubes faster, with less lock ups and pops, virtually

no pops at all now. So basically all of the problems I was having from my cube were due to improper tensioning. Along with the benefit of having less feedback

from your cube I think this will also allow cubers to more effectively communicate their tensions. For example, instead of saying I set my tensions loose or tight

or somewhere in between, I would say ”my main speedcube is a type c 1 and my tensions are set to 1.371 mm.” I modified my gap gauge so that it would fit

around the core screw making it much more accurate and easier to tension. If anyone has any helpful hints or if I’m missing something, or if even you feel this is

all crap, please include why, I would appreciate your input. Also if enough people want me to make a video, please say so below.:D

EDIT: video link http://www.youtube.com/watch?v=fje6lrRCLFw hope this catches on if people find that it really helps. Please ask me any questions if you have any.
Poll

My idea is that i will buy the gap gauge, modify it myself, then send it out to someone to try it and then that person can send it to someone else and so on and so forth. So what i wondering is if people will be willing to try this idea and then ship it to a fellow cuber for just the cost of postage. (50 cents or so). I think if about 10 people are interested i will buy a gauge and make a list of people.

Interesting New Method: a bit of everything

Smiles — Sat, 02 Mar 2013 09:20:15 GMT

So I came up with a new method and it's not so great speed-wise, but it's quite interesting and I just feel like it's not optimized.
And I guess people will say that Roux defeats this method, and I can almost certainly agree on that.

Anyway, there are 5 main steps in the method, although you could break it down to 7 different steps.

1. Build a 1x2x3 block. This step is the same as Roux.
2. Orient all the edges (9). The concept of this step can be viewed in different ways, like doing moo or the ZZ way, which are essentially the same thing. However, the centers are free (Roux) and the whole cube is somewhat free at the same time (ZZ).
3. Place the DB edge to DB. Don't ask why.
4. Build another 1x2x3 block opposite the first one, while placing the FD edge. This can be broken down into 2 steps, building a 2x2x2 block that includes the FD edge, then inserting the CE pair at the back (example solve 2 & 3). Or, make two 1x2x2 blocks (example solve 3 redone).
5. Solve the last layer. Since the edges are oriented, this opens up some options. LS methods like WV can be used, or OCLL/PLL, COLL/EPLL, straight up ZBLL, whatever.

Step 4 is took me a while to figure out, but I did it :) and you can see how it works in the example solves.

Spoiler:

Pros
- Like Roux, this method doesn't require rotations (unless they exist in the LL algs but algs are algs).
- Mostly .
- Good look ahead since EO is done and the DB edge is done. Not as good as Petrus, but better than ZZ.

Cons
- Can be hard to identify bad edges in step 2, since there are so many and they're all around the cube. However, planning the entire first block during inspection can hint as to which ones are the bad edges.
- Sometimes move restrictions (from EO and 1st block) get in the way.
- Step 4 has a lot of moves and is complicated, like tracking 2 edges + a CE pair all at once.

I had been trying to come up with a new method when I was bored, and this is the only usable idea that came to mind.

Columns modified method reconstructions

Derads — Wed, 27 Feb 2013 18:06:25 GMT

Hi, well I thought I had invented a new method when I tried to put the "F2L" pairs before making any cross, then orienting and permuting the last 4 corners, finish the bottom layer edges with an easy and fast sequence of moves and finally finishing the last edges with few ELL cases, then I realized that there was a very similar method called Collumns, but with some differences, with this method my PB avg5 is 14.20 seconds, so you could say is pretty fast sometimes, it really depends on how you visualize. I can predict the first two pairs at the inspection most of the time, but well, here are my reconstructions:

1. Scramble:
R B2 U' D2 F' U L D2 B L' D B2 F2 U' L2 B2 R L D2 B' F R2 U' F L U2 D2 L' U F'

Inspection: x2 y2
P1: F L' D'
P2: x' r' D R L y
P3: M' U' R M
P4: y' R' U' R U' R' U R
CMLL: R2 D' R U2 R' D R U2 R
LBE: D M' U M U' M U M' D' M' U2 M2 U2 M'
ELL: y M' U' M' U2 M' U M U' M' U2 M U M2 U2

2. Scramble:
F' D U R' D' U' R2 D' F' R2 B2 U2 L' D2 U2 B R U D' L' F2 B' U2 R' B U R' F' L U'

P1: L u L
P2: y L U L'
P3: R U R' L' U' L U L' U' L U L' U' L
P4: U2 R U2 R' U R' F R F'
CMLL: L U L' U L U2 L'
LBE: D U' M U' M2 U' M D' M' U' M U' M U2 M'
PLL: U2 R' U R' U' R' U' R' U R U R2

3. Scramble:
U' F2 B2 D' U' R' B2 U R' F' D B2 U2 R' D2 B2 F' D' B F2 D L' F' R' D L' U2 B2 D' L2

Inspection: x2
P1: U' R'
P2: y' L'
P3: U' R U R' U L U L'
P4 y U2 M' L' U l
CMLL: U2 F R U R' U' F'
LBE: M' U M D' U' M' U2 M2 U M' U' M U2 M' D
ELL: M U R U R' U' r2 R2' U R U' r'

Hope it worked for you, please leave your opinion.

Luka Ruzic

Edges Last method

somerandomkidmike — Tue, 12 Feb 2013 21:40:43 GMT

I've named this the "Edges Last Method" because I couldn't think of anything better. I came up with this method a few months ago while messing around with L2Lk. It shares a lot in common with L2Lk/L2L4.

Edit: I've decided to go with TheNextFelix and call the method LC2E. It's not a perfect description, but it does distinguish the method from others.

ANYWAY! Because I don't know how much potential this method has, I've been a little reluctant to share it with the speedsolving community. I DO plan on learning all the algorithms. For the most part, they'd be useful to me, regardless of whether I switch to this method or not.

So, here it is.

Step 1- Left 1x2x3 block (10 moves)

Yup. It's the same as the first step of Roux. If you don't know how to do this, find a different tutorial. I'm not going to explain it.

Step 2- Finish the Left Layer and place 2 Edges on the Second Layer (18 moves)

This is the hardest step, and it requires the most explanation. It is fairly intuitive, but there are several ways you can accomplish this step. Except for a few Advanced cases, you'll probably be using U, R and M moves for this step. In some cases you'll have to move paired blocks "out of the way" before positioning the paired blocks.

Here are just a couple of examples of techniques you can use.

1) Solve the two middle layer edges first, then solve the rest of the first layer.
2) Solve one Edge in the middle layer and 2 pieces in the first layer, then use F2L.
3) Place 2 edges in the middle layer oriented correctly, and position them while solving the first layer.
4) A combination of 1, 2 and 3.

I do plan on providing further documentation to this, but for the most part, I just want to get the general idea out there before I change my mind, and decide not to post anything.

Step 3- CLL (9 moves, 40 cases)
You could use CMLL, CLL, and some Corners First algorithms. The advantage you get here is that there are 2 slots in the middle layer that you can ignore, so you can use the shorter CF algorithms in place of the CLL. (ie. R2 U R U2 R2, rather than R U2 R' U' R U R' U' R U' R')

Step 4- Last 2 Edges (9 moves, 36 cases)
From now on, it's the "edges last" portion. Yes, I got this straight from Stachu Korick's webpage about L2Lk. You can find the algorithms here if you don't know what I'm talking about. http://stachu.cubing.net/l2lk/

Step 5- ELL (11 moves, 29 cases)
ELL has been documented in many different places. This is not new for the speedsolving community. I'm sure you can find information on it.

_____
Total Movecount: 57 STM
Total algorithm count: 105
_____

So, there you have it. Obviously, there are a lot of algorithms to learn for this method, so it might be intimidating. Do I think this method can be any good? I have no clue. I guess I'll wait to see what the rest of you have to say about it.