who wants to share ideas to make the WORST METHOD for 3x3 with a few rules, (please give this post a glance)

[Garf]

Bro we talking worse that has blockbuilding so not bad enough for the worst method

Fine. You make the Roux Block + the 2x2 blocks pseudo blocks. Then you have to do an algorithm to solve the blocks, which would do EO as well.

 

[Twisted101]

Fine. You make the Roux Block + the 2x2 blocks pseudo blocks. Then you have to do an algorithm to solve the blocks, which would do EO as well.

I don’t think you understand, we are trying to make an extremely bad method, while you are suggesting algorithms that solve multiple things and blockbuilding which is not the recipe for a bad method. It seems you are just make an average method

 

[the_chad]

roux

 

[Thom S.]

What do we consider stalling?
Obviously, doing e.g. PLL, but every individual move has a U2 U2' in between is stalling, but I count that as algorithmic stalling. Artificial, if you will. I'd find it more interesting to find steps that have the intent of solving but do so inefficiently - and - with many regrips.

For example
1. Solve DF, DR and FR
2. Solve DFR
Solves a 2x2, but does so in a very inefficient way, would this count as stalling?

Another example
Solve 3/4 of a cross
Do F2L
[Insert the missing cross edge]
Guarantees that at one point in your F2L you have to change grip for just one piece and then change grip back to home. Would this be considered stalling?

roux

I can see the Clown has returned from Clown school.

 

[n0nco]

What do we consider stalling?
Obviously, doing e.g. PLL, but every individual move has a U2 U2' in between is stalling, but I count that as algorithmic stalling. Artificial, if you will. I'd find it more interesting to find steps that have the intent of solving but do so inefficiently - and - with many regrips.

For example
1. Solve DF, DR and FR
2. Solve DFR
Solves a 2x2, but does so in a very inefficient way, would this count as stalling?

Another example
Solve 3/4 of a cross
Do F2L
[Insert the missing cross edge]
Guarantees that at one point in your F2L you have to change grip for just one piece and then change grip back to home. Would this be considered stalling?

yeah i think just doing it inefficiently would be "best" way maybe the algs could have manys regrip as you said, i have no idea what you mean by df dr fr and dfr, i wouldn't say regriping to do a pair would be considered stalling

 

[Jorian Meeuse]

For example
1. Solve DF, DR and FR
2. Solve DFR
Solves a 2x2, but does so in a very inefficient way, would this count as stalling?

That can only be considered stalling with the logic 'solving x in a worse way purposefully is stalling', but if you apply that logic you have to allow x to be anything, even the whole cube. So considering that stalling is essentially saying 'we want the worst method to solve x (x=rubiks cube), but we don't allow purposefully bad methods', which kinda defeats the purpose of the whole thread. So no, that's not stalling.

I think a good way to define the rules would be:
The method has to be described as a series of n steps (with n finite), where every step reduces the number of states the rubiks cube can be in after the step (so fewer than 43 quintillion bla bla bla possible states after step one), and any state that is eliminated after step x is not allowed back in the pool of possible states after step y, where y>x. After n steps, the only possible state must be a solved cube.

I think this would imply that the worst method is to just assign a number to every scramble, and have step x be 'make sure the cube is not in state x, and not in any state y with y<x'. Since you only assign numbers to scrambles, not the solved cube, after 43 quintillion bla bla bla steps, the cube will be solved. Granted, you'll get a lot of skips, but I feel like a worse method is not possible.

 

[THE_V01DL0RD]

I don't know what do you mean by bad.
Bad as in speed, or movecount, or ergonomics, or alg count.
I do have a method where the last step needs you to memorize >1000 algs.
Solve the First layer any way you want
Solve the second layer normally,
OLL
PBL
I think I shared this before tho

 

[fes_77]

OAP
PAP

orient all pieces
permute all pieces

Spoiler

idk what im thinking im jst tired : (

 

[AdvantageousFrog]

I think this would imply that the worst method is to just assign a number to every scramble, and have step x be 'make sure the cube is not in state x, and not in any state y with y<x'. Since you only assign numbers to scrambles, not the solved cube, after 43 quintillion bla bla bla steps, the cube will be solved. Granted, you'll get a lot of skips, but I feel like a worse method is not possible.

You could make this worse by assigning a number to each state, then making step x 'If the cube is in state x, make the cube match state x+1'. Then, instead of using a good method to make it match the desired state for each step, you could first permute each piece individually, like old pochmann but without orientation and using a terrible algorithm, then orient each piece individually by first swapping it with a buffer piece, then doing setup moves to swap it back using the same alg(For example, (T Perm) L d' L (T Perm) L' d L' flips UR, and UL is the buffer piece. Of course, you would use a worse alg than a T Perm.) So basically, old pochmann but worse. Just one step would have a staggering movecount, and on average it takes >21 quintillion steps. So yeah, it's not great.

 

[Jorian Meeuse]

You could make this worse by assigning a number to each state, then making step x 'If the cube is in state x, make the cube match state x+1'. Then, instead of using a good method to make it match the desired state for each step, you could first permute each piece individually, like old pochmann but without orientation and using a terrible algorithm, then orient each piece individually by first swapping it with a buffer piece, then doing setup moves to swap it back using the same alg(For example, (T Perm) L d' L (T Perm) L' d L' flips UR, and UL is the buffer piece. Of course, you would use a worse alg than a T Perm.) So basically, old pochmann but worse. Just one step would have a staggering movecount, and on average it takes >21 quintillion steps. So yeah, it's not great.

To do this, you would have to change the definition of the rules again, and I would not see how.
Because the definition I gave (which I still think is the most straightforward one) says that each step must reduce the number of possible states. However, with your method, that number of possible states keeps returning to 1, so it is not a continuous reduction. Objectively, the slowest way to have continuous reduction here is to go down by one on every step, since you are bound to natural numbers. That means the number of steps can't exceed 43 quintillion bla bla bla. Hence, the number of steps in the worst possible method must have 43 quintillion steps (assuming we are talking worst on average, taking each possible scramble into account). The method I prescribed has that property, and in fact, since there are many ways you can number the scrambles, there are 43! methods like that.

 

[FenTheGoat]

I Think this post should be renamed to the “worst human viable method”

You could make this worse by assigning a number to each state, then making step x 'If the cube is in state x, make the cube match state x+1'. Then, instead of using a good method to make it match the desired state for each step, you could first permute each piece individually, like old pochmann but without orientation and using a terrible algorithm, then orient each piece individually by first swapping it with a buffer piece, then doing setup moves to swap it back using the same alg(For example, (T Perm) L d' L (T Perm) L' d L' flips UR, and UL is the buffer piece. Of course, you would use a worse alg than a T Perm.) So basically, old pochmann but worse. Just one step would have a staggering movecount, and on average it takes >21 quintillion steps. So yeah, it's not great.

 

[AdvantageousFrog]

each step must reduce the number of possible states.

Sorry, I forgot about this. You are correct that no method with this definition of step can exceed 43,252,... steps. I also didn't realize you considered most steps to be worst. If this is the case, your method is the worst possible method, along with countless others. The point of my method was that it had a higher movecount, and fewer steps are skipped. Of course, movecount isn't an ideal way to measure how good or bad a method is either. The problem is that the worst method depends entirely on how worst is defined. So your method is not necessarily the worst, but it does have the highest number of steps. My method is also not necessarily the worst, but has a very high average number of moves.

The problem with trying to determine the worst method, or worst anything, is that what the worst is depends entirely on how a good thing is defined. For some, it's straightforward. For example, if you're in a competition with 99 other people, the worst result you can get is last place, because a good result is defined as closer to first place. For the worst method, this is a lot more difficult.

I Think this post should be renamed to the “worst human viable method”

I think this could be a good idea, but it still has two issues. One is that, again, a worst method is hard to define. I think the best way to do it would be for someone to use the method and see what time they get, but some methods might be very hard to learn or get good at, and the time would depend on the solvers skill. The other issue is that it's hard to determine what human viable means. For example, is 1lll a human viable method for the last layer? For most people, no, but it is possible. And what about a method like what's used in FMC? It's not exactly viable for speedsolving, but it's a viable way to solve the cube, and if we want bad times, one way to achieve that would be stretching the limits of what is humanly possible, which is effectively what is done in FMC.

The worst method is entirely dependent on what defines worst. I propose that instead of trying to find one thing that can be measured to determine how good a method is, people can just make a method that is bad in some aspect that they think is important. We don't necessarily need an objective measurement to come up with methods that are very bad. If we try to find the objective worst method, we'll spend as much time arguing about what counts as worst than making methods. So instead, we can just make bad methods and be happy.

 

[Jorian Meeuse]

Sorry, I forgot about this. You are correct that no method with this definition of step can exceed 43,252,... steps. I also didn't realize you considered most steps to be worst. If this is the case, your method is the worst possible method, along with countless others. The point of my method was that it had a higher movecount, and fewer steps are skipped. Of course, movecount isn't an ideal way to measure how good or bad a method is either. The problem is that the worst method depends entirely on how worst is defined. So your method is not necessarily the worst, but it does have the highest number of steps. My method is also not necessarily the worst, but has a very high average number of moves.

The problem with trying to determine the worst method, or worst anything, is that what the worst is depends entirely on how a good thing is defined. For some, it's straightforward. For example, if you're in a competition with 99 other people, the worst result you can get is last place, because a good result is defined as closer to first place. For the worst method, this is a lot more difficult.

Sorry, I should have been more clear about what i consider 'worse'. Since we are talking speedcubing, I thought of 'the worst method' as meaning 'the method that is most likely to give a slower result to a random scramble than all other possible methods'. That means it is not directly 'the method with the most amount of steps', which is why I said '(assuming we are talking worst on average, taking each possible scramble into account)' in my previous post. So then, why is this method the worst? Well. The further you are into the solve, the more difficult each step gets. This is because you have to take more and more scrambles into account. If we define how complicated a step is as how many states it eliminates, each method is precisely equally complicated (an equal decreasy of entropy, if you will). Now we define how difficult a step is as how many states have to be avoided after completing the step (I won't go into detail, but thk k about why this makes sense). This is why things like cross are easy and intuitive, but OLL and PLL are algorithmic. Now, the more steps a method has, the higher the average difficulty of all steps during the solve, the higher the probability of getting a bad time. This is not a very rigorous proof or anything, but I think this should give you an idea as for why this method is the worst possible.

Lastly, if slowness is what makes a method bad, why isn't your method worse than mine? It is clearly slower. However, your method isn't a method. At least, not by this definition. It is just to get the cube into whatever you label state 2, and from there, every solve is precisely identical. If anything is stalling, itnis clearly that.