# ksolve+ v1.0 - general-purpose algorithm finder

#### qqwref

##### Member
I'm not sure exactly what's going on here, but if you aren't generating the 13-move algs there must be something wrong with either your move definitions or your scramble. I notice that both U and M don't change orientations of edges, but other than that, I dunno what's wrong. Have you tried applying some alg scrambles and seeing if the results make sense?

#### Puggins

##### Member
My exe file is broken. It pops up with a small console then goes away

#### kentaro24

##### Member
I wrote a definition file for Gear Shift.
Code:
Name Gear Shift

# def-file by Kentaro Nishi
# BIGCORNERS: UBR UFL DFR DBL
# SMALLCORNERS: UBL UFR DFL DBR
# Move "U" indicates pull U-face and turn small corners in U-face clockwise 72 degrees.
# Move "A" indicates turn all small corners clockwise 72 degrees.

Set BIGCORNERS 4 8
Set SMALLCORNERS 4 5

Solved
BIGCORNERS
1 2 3 4
0 0 0 0
SMALLCORNERS
1 2 3 4
0 0 0 0
End

Move U
BIGCORNERS
1 2 3 4
7 7 0 0
SMALLCORNERS
1 2 3 4
1 1 0 0
End

Move D
BIGCORNERS
1 2 3 4
0 0 7 7
SMALLCORNERS
1 2 3 4
0 0 1 1
End

Move F
BIGCORNERS
1 2 3 4
0 7 7 0
SMALLCORNERS
1 2 3 4
0 1 1 0
End

Move B
BIGCORNERS
1 2 3 4
7 0 0 7
SMALLCORNERS
1 2 3 4
1 0 0 1
End

Move R
BIGCORNERS
1 2 3 4
7 0 7 0
SMALLCORNERS
1 2 3 4
0 1 0 1
End

Move L
BIGCORNERS
1 2 3 4
0 1 0 1
SMALLCORNERS
1 2 3 4
1 0 1 0
End

Move A
BIGCORNERS
1 2 3 4
7 7 7 7
SMALLCORNERS
1 2 3 4
1 1 1 1
End

Last edited:

#### Robert-Y

##### Member
iirc blocking is limited to 8 blocks (qqwref: can you confirm?).

I think even if it can handle all the blocking, it wont be able to search for long and useful algorithms because there are so many pieces to define. If you're interested in algorithms with minimal effects e.g. swapping two centres then ksolve might be able to handle it fast, depending on the move restriction e.g. <RUF>

#### qqwref

##### Member
I'm not sure about a limit on the number of bandaged pieces - I just remember a limit on the number of pieces of a given type you can ignore at once.

For Crazy 3x3 Plus cubes, though, bandaging pieces is not really what you want, because it's meant for specifying that a group of pieces can only be moved together as a group. All you have to do is, when you define the 6 moves, specify exactly what they each do to the corner-center and edge-center pieces - some of the moves will do two 4-cycles and some will do four.

#### psi

##### Member
I'm not sure about a limit on the number of bandaged pieces - I just remember a limit on the number of pieces of a given type you can ignore at once.

For Crazy 3x3 Plus cubes, though, bandaging pieces is not really what you want, because it's meant for specifying that a group of pieces can only be moved together as a group. All you have to do is, when you define the 6 moves, specify exactly what they each do to the corner-center and edge-center pieces - some of the moves will do two 4-cycles and some will do four.
Ok, I guess this could work for face turns which do not move centers. But I still don't see how I could model a slice turn like M which, for example, changes U center which could then change effect of the next U move (if U center switches from 0 to 1).

#### qqwref

##### Member
Yeah, trying to model slices wouldn't really be possible because of the changing effects of a given move. ksolve expects every move to do a specific thing, and the bandaging really only restricts what moves are possible - it wouldn't allow a given turn to have different effects based on the bandaged state. I suppose you could define some kind of invisible pieces, which would be bandaged together, so that for instance only one of U (turns center) or u (doesn't turn center) is possible at once... but then you'd have two types of each turn and potentially four types of each slice turn, and that would be pretty ugly.

If you are really interested in finding algorithms with slice moves, I'd suggest adding some extra slack (allowing the program to find longer solutions) and then seeing if any of the longer-than-optimal algs have moves like R L' in them.

#### psi

##### Member
If you are really interested in finding algorithms with slice moves, I'd suggest adding some extra slack (allowing the program to find longer solutions) and then seeing if any of the longer-than-optimal algs have moves like R L' in them.
Nice, I think a further step with this idea, to force only slice turns, would be to define the move "RL' " in place of R and L. This move would do both turns even though this has the limit that the next U turn would be instead B. Also this would allow only one of the three slices.
Rotations are not possible (moves x,y,z) for the same reason that they switch centers.
Anyway thanks.

#### bilde

##### Member
This is slightly off topic but I have created a facebook group called "Algorithm searchers" https://www.facebook.com/groups/361282697377249/

If you are having trouble getting ksolve to work or you would like some advice/tips, don't be afraid to join
Hello,

I was wondering if this group is still active? I requested to join it but I'm pretty sure my request was declined :/

#### Robert-Y

##### Member
Hiya, I'm sorry I probably declined your request because I was getting a few requests from "random" people. I don't want to let in people who are simply lurking. I would like people to contribute to discussions and/or learn how to search for algorithms. But please request to join again and I'll accept it

#### bilde

##### Member
Hello,

I've been wanting to solve only the corner permutation and leaving only the left "ZZ block" intact (such as the algorithms described in this thread: https://www.speedsolving.com/forum/showthread.php?43236-New-Approach-to-ZZ-d).

I've tried using CubeExplorer for this, and also ksolve+ (ignoring orientation but not permutation), with no luck - I can get algs that permute the corners, but this also makes it so that the corners are in their actual places, while I want the pieces to be scrambled, so that I have a 2gen-scramble.

I figured ksolve+ is probably the tool that most likely can achieve this, but I've had no luck. Is ksolve+ not the right tool for this, or is my approach wrong / do I need to do some other definition file wizardry?

#### Lucas Garron

##### Moderator
Staff member
Hello,

I've been wanting to solve only the corner permutation and leaving only the left "ZZ block" intact (such as the algorithms described in this thread: https://www.speedsolving.com/forum/showthread.php?43236-New-Approach-to-ZZ-d).

I've tried using CubeExplorer for this, and also ksolve+ (ignoring orientation but not permutation), with no luck - I can get algs that permute the corners, but this also makes it so that the corners are in their actual places, while I want the pieces to be scrambled, so that I have a 2gen-scramble.

I figured ksolve+ is probably the tool that most likely can achieve this, but I've had no luck. Is ksolve+ not the right tool for this, or is my approach wrong / do I need to do some other definition file wizardry?
Try ACube for easier ways to ignore orientation and permutation separately on 3x3x3.

#### supercavitation

##### Member
Does anyone have a full Square-1 def file (i.e. one that can leave cube shape)? I'm not 100% sure it's possible, but if it is, it would be incredibly useful.

#### bilde

##### Member
Try ACube for easier ways to ignore orientation and permutation separately on 3x3x3.
Hello, and thanks for the reply!

I've tried ACube aswell, but with no luck. I don't think I explained what I want clearly enough in my first post.

R U R' F' R U R' U' R' F R2 U' R' L' U' L U2 // setup
// Input to ACube: (UR UB) (FL UL) (UBR ULF) (DLF ULF) ULB? ULF+ DLF? UFR? UBR? DFR? DBR? [UR UF UL UB FR BR DR]
ACube solution: U' R U' L' U L R'
However, I want a solution like this one:

R2 U2 L' U L
I don't know if any program is able to permute corners in this way, and I can't get it to work with ACube either. :-(

Does anyone have a full Square-1 def file (i.e. one that can leave cube shape)? I'm not 100% sure it's possible, but if it is, it would be incredibly useful.
I gave it to supercavitation in IRC, but in case anyone else is interested:

Code:
Name sq1full

# def-file by Andrew Nelson

# pieces are: UFL UFLx UL UBL UBLx UB UBR UBRx UR UFR UFRx DFL DFLx DL DBL DBLx DB DBR DBRx DR DFR DFRx
# x pieces are bandaged

Set EDGES 24 1

Solved
EDGES
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
End

Move U
EDGES
12 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16 17 18 19 20 21 22 23 24
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
End

Move D
EDGES
1 2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 13
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
End

Move R
EDGES
1 2 3 4 5 6 24 23 22 21 20 19 13 14 15 16 17 18 12 11 10 9 8 7
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
End

Block
EDGES
1 2
End

Block
EDGES
4 5
End

Block
EDGES
7 8
End

Block
EDGES
10 11
End

Block
EDGES
13 14
End

Block
EDGES
16 17
End

Block
EDGES
19 20
End

Block
EDGES
22 23
End

#### ch_ts

##### Member
Hi Bilde!
I threw together a solver that will do what you want. I am not totally familiar with zz-d, but I think this may be correct. Please check the following sample scrambles and solutions to see if this is what you need.

R1U1R3F3R1U1R3U3R3F1R2U3R3L3U3L1U2
R2U1L3U2L1

L3U1L1R2U1F1B3R2F3B1U1R2U1
U1R2U3R1L3U1L1

L3U2L1F1B3R2F3B1U1
R1U3L3U2R1U3R2U3L1

L3U1L1R2U1F1B3R2F3B1U1R2U1
U1R2U3R1L3U1L1

Sorry about the notation if it's inconvenient, I threw the solver together quickly. Hope it is useful for you!

#### Attachments

• 6.9 KB Views: 10

#### bilde

##### Member
@ch_ts:

This is exactly what I wanted, so really, thank you very much for taking the time to put this together for me! I really appreciate it. It would be nice to have the solver return non-optimal solutions too, however the solver already seems to already generate decent algorithms, as the ones I want are really just short RUL algorithms. Though now that you've shown me this, I'm really curious as to how you implemented this. Would you mind sharing the source code? I'm totally fine with you not wanting to either, I already appreciate this tons.

Thanks again!

Edit: My apologies to the moderators if this is getting a little off topic from ksolve+.