Developing a better LL system

Noahaha · May 12, 2012

A lot of LL situations are just a 3-cycle of corners and a 3-cycle of edges. It would only be like 20 algs to give a lot of 2-alg 1LLLs.

EDIT: 12 edge cycles and 12 corner cycles, and not too bad algs either.

Cubenovice · May 14, 2012

Wondering if the calculations have finished?
I will not ask for the organising part (yet)

aronpm · May 14, 2012

Cubenovice said:
Wondering if the calculations have finished?
I will not ask for the organising part (yet)

yep, I've sent them back, but Kir has been partying hard

FatBoyXPC · May 14, 2012

Kirjava: Your T-Perm Sune example, is there any reason why one wouldn't use one of the standard COLL cases for that? I don't know COLL so my only guess is that it's a bad COLL case if you'd rather use your example (or unless it was just an example to show 2 common algs in a different order than one would normally use in CFOP).

Kirjava · May 15, 2012

Table is complete! Thanks to aron for running the program and dan for converting the position matricies into LL images for me.

raw table (essentially unlearnable in current format)

Next job is to organise this stuff. Gonna take me quite a while on my own, but I'll see if I can get people to help once I've got the ball rolling.

Here's the solver incase anyone is interested; (thanks to jlaire for helping me refactor)

Code:

#!/usr/bin/perl
use strict;
use warnings FATAL => 'all';

print "LL Solver\n\n";

# UBL & UB
# EP EP EP EP EO EO EO EO CP CP CP CP CO CO CO CO
# orientations applied after permutations	

# input

my $mode = 0; # 0 = everything, 4 = OLLCP, 8 = CLL
my @case = qw(0 1 2 3 0 0 0 0 0 1 2 3 0 0 0 0);
my @solved1 = qw(0 1 2 3 0 0 0 0 0 1 2 3 0 0 0 0);
my @solved2 = qw(3 0 1 2 0 0 0 0 3 0 1 2 0 0 0 0); # U
my @solved3 = qw(1 2 3 0 0 0 0 0 1 2 3 0 0 0 0 0); # U'
my @solved4 = qw(2 3 0 1 0 0 0 0 2 3 0 1 0 0 0 0); # U2

my @basealgs =  ( 
[qw(0 1 2 3 0 0 0 0 0 1 2 3 0 0 0 0), ''],
[qw(1 3 2 0 0 0 0 0 2 3 0 1 1 0 1 1 Sune)],
[qw(3 0 2 1 0 0 0 0 0 1 2 3 2 1 2 1 DoubleSune)],
[qw(0 1 2 3 0 0 0 0 2 3 0 1 0 1 0 2 TripleSune)],
[qw(0 3 2 1 0 0 0 0 0 2 1 3 0 0 0 0 TPerm)],
[qw(0 3 1 2 0 0 1 1 2 3 0 1 1 0 1 1 FatSune)],
[qw(0 2 3 1 0 1 1 0 0 1 2 3 2 1 2 1 DblFatSune)],
[qw(2 3 0 1 0 0 1 1 2 3 0 1 2 0 2 2 RUR2FRF2UF)], # PureSune
[qw(0 1 2 3 0 1 1 0 0 1 2 3 1 1 1 0 LU2L'U'LU'xU2R'U'RU'r')], # PureFat
#[qw(2 3 0 1 1 1 1 1 2 3 0 1 2 0 2 2 FURU'R'F'R'F'U'FUR)], # AllSune
#[qw(2 3 0 1 0 0 0 0 0 1 2 3 1 1 0 1 R'U2R2UR2URU'RU'R')], # SuneH
[qw(0 3 1 2 0 0 1 1 0 2 3 1 1 1 0 1 L'U2LU2LF'L'F)], # C2
[qw(0 3 1 2 0 0 1 1 2 1 3 0 1 1 0 1 FR'F'RU2RU2R')], # C3
[qw(1 2 0 3 0 1 1 0 1 0 3 2 0 2 1 0 FRUR'U'F')], # FRURUF
[qw(2 0 1 3 1 0 1 0 0 1 2 3 2 2 1 1 FRUR'U'RUR'U'F')], # DblFRURUF
[qw(0 1 2 3 0 0 0 0 3 1 0 2 2 0 0 1 L'R'D2RU2R'D2RU2L)], #Opp3
[qw(1 2 3 0 0 0 0 0 2 0 3 1 1 1 0 1 Niklas)], # RU'L'UR'U'L
[qw(3 1 0 2 0 0 1 1 1 2 0 3 1 1 1 0 rU'r'U'rUr'F'UF)], #WeirdNiklas
[qw(2 3 0 1 1 0 0 1 1 2 0 3 1 1 1 0 RU'R'U'F'U2'FU2RU2R')], # FatNiklas
[qw(0 1 2 3 0 0 0 0 0 2 3 1 0 0 0 0 APerm)], # A Perm
[qw(0 3 1 2 0 0 0 0 0 1 2 3 0 0 0 0 UPerm)], # U Perm
[qw(2 3 0 1 0 0 0 0 0 1 2 3 0 0 0 0 HPerm)], # H Perm
[qw(1 2 0 3 0 1 1 0 1 3 2 0 0 2 0 1 SexyHammer)], # RUR'U'R'FRF'
[qw(0 1 2 3 0 0 0 0 1 3 2 0 0 2 0 1 rUR'U'r'FRF')], # FatSexyHammer
[qw(3 1 2 0 0 0 1 1 1 0 2 3 2 0 0 1 R'FRUR'U'F'UR)], # HardP
[qw(0 2 3 1 0 0 1 1 1 0 3 2 1 0 0 2 R'U'R'FRF'UR)], # EasyC
#[qw(2 3 0 1 1 1 1 1 0 1 2 3 0 0 0 0 MURUR'U'M2URU'r'U')], # HFlip
[qw(3 1 2 0 1 0 1 0 0 3 2 1 2 0 0 1 R2'U'RFR'UR2U'R'F'R)], # DiagT
[qw(0 3 2 1 0 0 0 0 2 3 1 0 2 1 0 0 FRUR'U'RU'R'U'RUR'F')], # TastyT
[qw(1 2 0 3 0 1 1 0 0 2 3 1 2 0 1 0 FRU'RDR'U2RD'R2'U'F')], # WeirdT
[qw(3 0 1 2 1 0 1 0 2 0 3 1 2 0 0 1 RUR'UF'L'ULFU'RU'R')], # PowerT
#[qw(1 3 2 0 1 0 0 1 1 3 2 0 1 0 0 2 L2F2R'FRF2L2U2LF'L')], # CheckU
#[qw(0 3 1 2 0 0 1 1 3 0 2 1 1 2 2 1 rUR'URUL'UR'U'LUM)], # RandomH
#[qw(0 1 2 3 0 0 0 0 0 1 2 3 0 2 0 1 F'RD2R'FU2F'RD2R'FU2)], # PureL
[qw(0 1 2 3 0 0 0 0 0 3 1 2 0 2 0 1 R2DR'U2RD'R'U2R')], # L3
[qw(1 2 0 3 0 1 1 0 0 3 1 2 2 1 0 0 FR2DR'URD'R2U'F')], # E2
[qw(3 1 0 2 1 0 1 0 0 3 1 2 2 1 0 0 fR2DR'URD'R2U'f')], # FatE2
[qw(2 1 3 0 1 0 1 0 1 2 0 3 0 1 2 0 F'LFL'U'L'UL)], # D5
[qw(2 0 3 1 0 0 0 0 3 1 2 0 1 2 1 2 RU'L'UR'ULUL'UL)], # G5
[qw(0 1 2 3 0 1 0 1 1 0 3 2 1 1 2 2 R'U'RU'R'UF'UFR)], # G6
[qw(1 2 3 0 0 1 0 1 0 2 1 3 1 0 0 2 FRU'R'U'L'U'LULF'L2UL)], # F4
[qw(1 2 0 3 0 1 1 0 2 0 1 3 2 2 1 1 FRUR'U'RF'rUR'U'r')], # H2Opp
[qw(1 2 0 3 0 1 1 0 0 1 2 3 0 0 0 0 RUR'U'M'URU'r')], # ezell A
[qw(3 0 2 1 1 1 0 0 0 1 2 3 0 0 0 0 M'UMU2M'UM)], # ezell 1
[qw(2 1 3 0 0 0 0 0 2 3 0 1 1 1 2 2 Bruno)], # Bruno
[qw(0 2 3 1 0 0 1 1 1 0 3 2 1 0 0 2 R'U'R'FRF'UR)], # BrestAlg
[qw(0 2 1 3 0 0 0 0 0 2 1 3 0 0 0 0 JPerm)]
);

my @eplookup =  ( 
[qw(0 1 2 3 0 1 2 3)],[qw(0 1 3 2 0 2 1 3)],[qw(0 3 1 2 0 2 3 1)],[qw(3 0 1 2 1 2 3 0)],[qw(0 2 1 3 0 1 3 2)],[qw(0 2 3 1 0 3 1 2)],[qw(0 3 2 1 0 3 2 1)],[qw(3 0 2 1 1 3 2 0)],
[qw(2 0 1 3 2 1 3 0)],[qw(2 0 3 1 2 3 1 0)],[qw(2 3 0 1 2 3 0 1)],[qw(3 2 0 1 1 3 0 2)],[qw(1 0 2 3 3 1 2 0)],[qw(1 0 3 2 3 2 1 0)],[qw(1 3 0 2 3 2 0 1)],[qw(3 1 0 2 1 2 0 3)],
[qw(1 2 0 3 3 1 0 2)],[qw(1 2 3 0 3 0 1 2)],[qw(1 3 2 0 3 0 2 1)],[qw(3 1 2 0 1 0 2 3)],[qw(2 1 0 3 2 1 0 3)],[qw(2 1 3 0 2 0 1 3)],[qw(2 3 1 0 2 0 3 1)],[qw(3 2 1 0 1 0 3 2)]
);

my @cplookup =  ( 
[qw(0 1 2 3 0 1 2 3)],[qw(0 1 3 2 0 1 3 2)],[qw(0 3 1 2 2 1 3 0)],[qw(3 0 1 2 1 2 3 0)],[qw(0 2 1 3 3 1 2 0)],[qw(0 2 3 1 3 1 0 2)],[qw(0 3 2 1 2 1 0 3)],[qw(3 0 2 1 1 2 0 3)],
[qw(2 0 1 3 1 3 2 0)],[qw(2 0 3 1 1 3 0 2)],[qw(2 3 0 1 2 3 0 1)],[qw(3 2 0 1 3 2 0 1)],[qw(1 0 2 3 1 0 2 3)],[qw(1 0 3 2 1 0 3 2)],[qw(1 3 0 2 2 0 3 1)],[qw(3 1 0 2 0 2 3 1)],
[qw(1 2 0 3 3 0 2 1)],[qw(1 2 3 0 3 0 1 2)],[qw(1 3 2 0 2 0 1 3)],[qw(3 1 2 0 0 2 1 3)],[qw(2 1 0 3 0 3 2 1)],[qw(2 1 3 0 0 3 1 2)],[qw(2 3 1 0 2 3 1 0)],[qw(3 2 1 0 3 2 1 0)]
);

my @colookup =  ( 
[qw(0 0 0 0 0 0 0 0)],[qw(0 1 1 1 2 0 2 2)],[qw(1 0 1 1 0 2 2 2)],[qw(1 1 0 1 2 2 2 0)],[qw(1 1 1 0 2 2 0 2)],[qw(2 2 2 0 1 1 0 1)],[qw(0 2 2 2 1 0 1 1)],[qw(2 0 2 2 0 1 1 1)],
[qw(2 2 0 2 1 1 1 0)],[qw(1 0 2 0 0 2 0 1)],[qw(0 1 0 2 2 0 1 0)],[qw(2 0 1 0 0 1 0 2)],[qw(0 2 0 1 1 0 2 0)],[qw(2 1 0 0 2 1 0 0)],[qw(0 2 1 0 1 0 0 2)],[qw(0 0 2 1 0 0 2 1)],
[qw(1 0 0 2 0 2 1 0)],[qw(1 2 0 0 1 2 0 0)],[qw(0 1 2 0 2 0 0 1)],[qw(0 0 1 2 0 0 1 2)],[qw(2 0 0 1 0 1 2 0)],[qw(1 1 2 2 2 2 1 1)],[qw(2 1 1 2 2 1 1 2)],[qw(2 2 1 1 1 1 2 2)],
[qw(1 2 2 1 1 2 2 1)],[qw(1 2 1 2 1 2 1 2)],[qw(2 1 2 1 2 1 2 1)]
);

my @ilookup =  ( 
[qw(0 1 2 3 0 1 2 3)],[qw(0 1 3 2 0 1 3 2)],[qw(0 3 1 2 0 2 3 1)],[qw(3 0 1 2 1 2 3 0)],[qw(0 2 1 3 0 2 1 3)],[qw(0 2 3 1 0 3 1 2)],[qw(0 3 2 1 0 3 2 1)],[qw(3 0 2 1 1 3 2 0)],
[qw(2 0 1 3 1 2 0 3)],[qw(2 0 3 1 1 3 0 2)],[qw(2 3 0 1 2 3 0 1)],[qw(3 2 0 1 2 3 1 0)],[qw(1 0 2 3 1 0 2 3)],[qw(1 0 3 2 1 0 3 2)],[qw(1 3 0 2 2 0 3 1)],[qw(3 1 0 2 2 1 3 0)],
[qw(1 2 0 3 2 0 1 3)],[qw(1 2 3 0 3 0 1 2)],[qw(1 3 2 0 3 0 2 1)],[qw(3 1 2 0 3 1 2 0)],[qw(2 1 0 3 2 1 0 3)],[qw(2 1 3 0 3 1 0 2)],[qw(2 3 1 0 2 3 1 0)],[qw(3 2 1 0 3 2 1 0)]
);

sub mirror($) {
	my ($alg) = @_;
	my @stuff = @$alg;

	my @buf;

	# EP
	for (0 .. 23) {
		if ($eplookup[$_][0] == $stuff[0] && $eplookup[$_][1] == $stuff[1] && $eplookup[$_][2] == $stuff[2] && $eplookup[$_][3] == $stuff[3]) {
			@buf[0 .. 3] = @{$eplookup[$_]}[4 .. 7];
			last;
		} 
		if ($_ == 23) {
			die "wrong EP or something\n";
		}
	}

	# EO
	@buf[4 .. 7] = @stuff[4,7,6,5];

	# CP
	for (0 .. 23) {
		if ($cplookup[$_][0] == $stuff[8] && $cplookup[$_][1] == $stuff[9] && $cplookup[$_][2] == $stuff[10] && $cplookup[$_][3] == $stuff[11]) {
			@buf[8 .. 11] = @{$cplookup[$_]}[4 .. 7];
			last;
		} 
		if ($_ == 23) {
			die "wrong CP or something\n";
		}
	}

	#CO
	for (0 .. 26) {
		if ($colookup[$_][0] == $stuff[12] && $colookup[$_][1] == $stuff[13] && $colookup[$_][2] == $stuff[14] && $colookup[$_][3] == $stuff[15]) {
			@buf[12 .. 15] = @{$colookup[$_]}[4 .. 7];
			last;
		} 
		if ($_ == 26) {
			die "wrong CO or something\n";
		}
	}

	$buf[16] = "Mrr($stuff[16])";

	return \@buf;
}

sub inverse($) {
	my ($alg) = @_;
	my @stuff = @$alg;

	my @buf;

	# EP
	for (0 .. 23) {
		if ($ilookup[$_][0] == $stuff[0] && $ilookup[$_][1] == $stuff[1] && $ilookup[$_][2] == $stuff[2] && $ilookup[$_][3] == $stuff[3]) {
			@buf[0 .. 3] = @{$ilookup[$_]}[4 .. 7];
			last;
		} 
		if ($_ == 23) {
			die "wrong EP or something\n";
		}
	}
	
	#EO
	@buf[4 .. 7] = (0,0,0,0);
	
	for (0 .. 3) {
		if ($stuff[$_ + 4]) {
			$buf[$stuff[$_] + 4] = 1; 
		} 
	}
	# CP
	for (0 .. 23) {
		if ($ilookup[$_][0] == $stuff[8] && $ilookup[$_][1] == $stuff[9] && $ilookup[$_][2] == $stuff[10] && $ilookup[$_][3] == $stuff[11]) {
			@buf[8 .. 11] = @{$ilookup[$_]}[4 .. 7];
			last;
		} 
		if ($_ == 23) {
			die "wrong EP or something\n";
		}
	}
	
	#CO
	@buf[12 .. 15] = (0,0,0,0);
	
	for (0 .. 3) {
		$buf[$stuff[$_+8]+12] = (3 - $stuff[$_+12]) % 3;
	}
	
	$buf[16] = "Inv($stuff[16])";
	
	return \@buf;
}

sub do_y($) {
	my ($pos) = @_;
	my @y;
	my @rebase = (3,0,1,2);
	for (0 .. 3) {
		my $base = $_ * 4;
		if ($_ == 0 || $_ == 2) {
			@y[$base .. $base+3] = map $rebase[$_], @{$pos}[$base+3, $base+0, $base+1, $base+2];
		}
		else {
			@y[$base .. $base+3] = @{$pos}[$base+3, $base+0, $base+1, $base+2];
		}
	}
	\@y;
}

sub add_alg($$) {
	my ($old, $new) = @_;
	#print "add_alg(@$old, @$new)\n";
	for (0 .. 3) {
		my $old_key = join " ", @{$old}[0 .. 15];
		my $new_key = join " ", @{$new}[0 .. 15];
		#print "$old_key <> $new_key\n";
		if ($old_key eq $new_key) {
			#print "SAEM!\n";
			return;
		}
		$old = do_y($old);
	}
	#print "DIFFURENT\n";
	push @basealgs, $new;
}

#Populate database with mirrors and inverses
my $orig_algs = @basealgs;
for (0 .. $orig_algs - 1) {
	add_alg($basealgs[$_], mirror($basealgs[$_]));
	add_alg($basealgs[$_], inverse($basealgs[$_]));
	add_alg($basealgs[$_], inverse(mirror($basealgs[$_])));
}

#Show array (debug)
#for $aref ( @basealgs ) {
#print "\t [@$aref],\n";
#}
#print "\n\n";

sub solved($) {
	my ($position) = @_;
	for my $solved (\@solved1, \@solved2, \@solved3, \@solved4) {
		my $equal = 1;
		for ($mode .. @$position - 1) {
			if ($position->[$_] != $solved->[$_]) {
				$equal = 0;
				last;
			}
		}
		if ($equal) {
			return 1;
		}
	}
	return 0;
}

sub domove($$) {
	my ($position, $alg) = @_;
	my @buf;
	# EP
	for (0 .. 3) {
		$buf[$_] = $position->[$alg->[$_]];
		$buf[$_+4] = $position->[$alg->[$_]+4]; #EO
	}
	# EO
	for (4 .. 7) {
		if ($alg->[$_]) {
			$buf[$_] = 1 - $buf[$_];
		}
	}
	# CP
	for (8 .. 11) {
		$buf[$_] = $position->[$alg->[$_]+8];
		$buf[$_+4] = $position->[$alg->[$_]+12]; #CO
	}
	# CO
	for (12 .. 15) {
		if ($alg->[$_]) {
			$buf[$_] = ($buf[$_] + $alg->[$_]) % 3;
		}
	}
	return @buf;
}

sub solve() {
	
	print "<td><script>ll(\"@case\");</script><br>";

	for my $auf1 (0 .. 3) {
		my $str_auf1 = ("", "U ", "U' ", "U2 ")[$auf1];
		my $alg_auf1 = (\@solved1, \@solved2, \@solved3, \@solved4)[$auf1];
		my @case1 = domove(\@case, $alg_auf1);
	
		if (solved(\@case)) {
			print "&gt; <br>";
			last;
		}

		for my $alg1 (1 .. $#basealgs) {
			my @case2 = domove(\@case1, $basealgs[$alg1]);
			if (solved(\@case2)) {
				print "&gt; $str_auf1$basealgs[$alg1][16]<br>";
				next;
			}
			for my $auf2 (0 .. 3) {
				my $str_auf2 = ("", "U ", "U' ", "U2 ")[$auf2];
				my $alg_auf2 = (\@solved1, \@solved2, \@solved3, \@solved4)[$auf2];
				my @case3 = domove(\@case2, $alg_auf2);

				for my $alg2 (1 .. $#basealgs) {
					my @case4 = domove(\@case3, $basealgs[$alg2]);
					if (solved(\@case4)) {
						print "&gt; $str_auf1$basealgs[$alg1][16] $str_auf2$basealgs[$alg2][16]<br>";
					}
				}
			}
		}
	}

	print "</td>\n";

}

my @ellp = qw(0 1 2 3 2 3 0 1 3 2 1 0 1 0 3 2 0 2 3 1 2 1 3 0 1 3 2 0 1 2 0 3 0 3 1 2 3 1 0 2 3 0 2 1 2 0 1 3);
my @ello = qw(0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 0 1 1 1 1 1);
my @cllo = qw(0 2 2 2 1 0 1 1 0 1 0 2 2 1 0 0 1 2 0 0 1 1 2 2 1 2 1 2);
my @cllp = qw(0 1 2 3 2 0 1 3 2 1 3 0 3 1 0 2 3 0 2 1 3 2 1 0);


for (my $co=0;$co<7;$co++){
	$case[12] = $cllo[($co*4)];
	$case[13] = $cllo[($co*4)+1];
	$case[14] = $cllo[($co*4)+2];
	$case[15] = $cllo[($co*4)+3];
	for (my $cp=0;$cp<6;$cp++){
		$case[8] = $cllp[($cp*4)];
		$case[9] = $cllp[($cp*4)+1];
		$case[10] = $cllp[($cp*4)+2];
		$case[11] = $cllp[($cp*4)+3];
		print "<tr>\n";
		for (my $eo=0;$eo<8;$eo++){
			$case[4] = $ello[($eo*4)];
			$case[5] = $ello[($eo*4)+1];
			$case[6] = $ello[($eo*4)+2];
			$case[7] = $ello[($eo*4)+3];
			for (my $ep=0;$ep<12;$ep++){
				$case[0] = $ellp[($ep*4)];
				$case[1] = $ellp[($ep*4)+1];
				$case[2] = $ellp[($ep*4)+2];
				$case[3] = $ellp[($ep*4)+3];
				solve();
				#print "<td><script>ll(\"@case\");</script></td>\n";	
				#print @case;print "\n";
				}
		}
		print "</tr>\n";
	}
}

print "\nEnd\n";

bamilan said:
Comparing OLL and your algorithms, they take ~ the same time to execute, but recog of OLL is better.
PLL algorithms are speed optimized, they can be done sub-2. Most of the algorithms in your list take at least 1-1.5 seconds to execute, so the time you can cut using that system is somewhere <0.5 sec in my opinion (assuming that recog for PLL is the same as recog for 2nd algorithm).

Your complaint is against the algorithms and not the system. I requested that everyone told me which algorithms they thought were not fast and suggested improvements to the list. Most if not all of those algs are sub1.

Second step recog is better than PLL. You don't know what first step recog is yet.

What you're missing (it's been not explicitly stated) is that good case distribution for this system is much much better.

Recog appears to be the only major concern, yet recog is easy and recall is actually the difficult part

LarsN said:
What is the solution with this new system then?

EDIT: just ran it through your list but didn't find a solution. Most likely a fail on my side though

No, you're right. It's actually unsolvable with this system.

There are around 10 cases like this. I'm thinking of either just generating algs for them for 1LLL when it comes up or doing some other thing (I have a few ideas). The probability of each appearing is 1/~4600, so not a huge deal at the moment.

aronpm said:
yep, I've sent them back, but Kir has been partying hard

fatboyxpc said:
Kirjava: Your T-Perm Sune example, is there any reason why one wouldn't use one of the standard COLL cases for that?

Because doing TPerm then Sune is better than doing COLL then EPLL?

MaeLSTRoM · May 15, 2012

OWOW that is awesome.
I'll help with the recog stuff if you like. This is gonna be fun

A Leman · May 15, 2012

I saw this thread a while ago but had my doubts(like how to get my head around it and the probability that you would follow through so fast) about it untill you put up the raw table. It is a very interesting idea. I will defidently put some time into your idea to help make it a method. Thanks kir, I was getting bored with all of the LS suggestions lately.

StachuK1992 · May 15, 2012

This is the coolest thing I've seen here in at least a year.

Kirjava · May 15, 2012

MaeLSTRoM made an image of the 'evil' cases;

Some are the same, I think he circled mirrors or something idk.

bobthegiraffemonkey · May 16, 2012

Kirjava said:
Setup: F R D2 F' R2 U B' R2 B U' R2 F D2 R' F' U

(R' l' U2 L U L' U2 R U' l') U (l' F2 x r' U' r U2 l' U R' U' l')

=OLLCP for adj corners and edge 2-flip + setup to J-perm. Not too bad, gonna keep looking maybe for the hell of it.

I know I'm late, but inverse of my first alg there is pretty nice, so is r' U r2 U' r2' U' r2 U r' plus mirror.

Edit: row 2, case 4: (U2) (F R' F' R U R U' R') U' ( (l R) U R' F' R U R' U' R' F R2 U' R' U' l')
More: SexyHammer [R f R' F': SexyHammer] = R U R' U' R' F R F' R f R' F' R U R' U' l' U R2 u' R'

Pyjam · May 16, 2012

What is your idea for case recognition and the choice of the first algorithm?

I believe that you need to know where to go with the first algorithm. In this case, it becomes a 1-LLL.

Godmil · May 16, 2012

Just had a look at the raw data... All those algs don't represent different cases do they? Like would you have to memorise them all?
I'm just not seeing how this could be humanly possible (well, maybe if someone was totally hardcore, but the recollection time would be immense).
Hope to be proven wrong though.

MaeLSTRoM · May 16, 2012

Godmil said:
Just had a look at the raw data... All those algs don't represent different cases do they? Like would you have to memorise them all?
I'm just not seeing how this could be humanly possible (well, maybe if someone was totally hardcore, but the recollection time would be immense).
Hope to be proven wrong though.

in each box is different algs for one case. THe recog system is being worked on, it's gonna take some time.

LarsN · May 16, 2012

I guess you may have noticed, but a lot of the algs can easily be removed because of double instances, like:

Sune - Jperm
Sune - inv(Jperm)

or

some alg - Hperm
some alg - U Hperm
some alg - U' Hperm
some alg - U2 Hperm

I wonder which alg for the first "step" is most commonly used ...

Kirjava · May 17, 2012

Pyjam said:
What is your idea for case recognition and the choice of the first algorithm?

I believe that you need to know where to go with the first algorithm. In this case, it becomes a 1-LLL.

I'm not exactly sure what you mean by your second statement, but I've started working on the case recognition side of things. A surprising amount of cases start with the same algorithm - Sune covers a *lot* of cases.

Still unsure if I should assume people know PLL etc. or not and just have it in a seperate section instead of included with the other cases. Advice on this would be good.

Godmil said:
Just had a look at the raw data... All those algs don't represent different cases do they? Like would you have to memorise them all?

Lol, nooo. Each case only needs one solution, and the number of cases you need to memorise will end up being quite a bit smaller than the number of actual LL cases.

LarsN said:
I guess you may have noticed, but a lot of the algs can easily be removed because of double instances, like:

Yeah, I just didn't incorporate the removal of things like that in the solver. Some duplication was removed, but not all of it.

Godmil · May 17, 2012

Kirjava said:
Lol, nooo. Each case only needs one solution, and the number of cases you need to memorise will end up being quite a bit smaller than the number of actual LL cases.

*Phew,
So how many cases roughly do you think people will need to memorise?

LarsN · May 18, 2012

Kirjava said:
Still unsure if I should assume people know PLL etc. or not and just have it in a seperate section instead of included with the other cases. Advice on this would be good.

My opinion is that it is safe to assume that most people looking at this LL approach also knows PLL. On the other hand, including the PLL cases doesn't seem like much of a difference compared to the number of total cases.

Kirjava said:
... and the number of cases you need to memorise will end up being quite a bit smaller than the number of actual LL cases.

This I don't understand. Aren't you supposed to be able to recognize all LL cases and then decide which alg to start with?
How far are you in the process of finding a good recognition system?

Kirjava · May 18, 2012

Godmil said:
So how many cases roughly do you think people will need to memorise?

I have no idea until it's done really.

LarsN said:
My opinion is that it is safe to assume that most people looking at this LL approach also knows PLL. On the other hand, including the PLL cases doesn't seem like much of a difference compared to the number of total cases.

I thought that, but then is it safe to assume people know ELL? L3C?

I wanted to have a seperate section for 'cases you should know' or something, but people who know them can just 1LLL then when they come up anyway. Including them as normal won't really cause a problem, and is a good idea if (/when) people start learning this instead of OLL/PLL.

LarsN said:
This I don't understand. Aren't you supposed to be able to recognize all LL cases and then decide which alg to start with?

Sort of. For many cases you will be recognising the specific LL case, but since some similar cases will start with the same alg you are able to ignore a large amount of stickers on them, and only have to learn recognition for one of them to cover them all.

I think it'll be clearer once a significant portion is documented. For me too, since the major shortcuts won't appear until I can see the patterns that crop up and can be taken advantage of.

LarsN said:
How far are you in the process of finding a good recognition system?

Dunno until it's finished. Recognition will be different depending on the case.

As far as documentation goes, the data so far seems interesting. Turns out that a significant portion of cases will start with the same alg, which should mean that the number of subsets will be small. No idea if that will make it easy to learn. I think the data will be constantly reorganised to make it easier even after it's 'finished'.

kashyap7x · May 20, 2012

Would this get much easier if edges were pre-oriented?

Escher · May 20, 2012

kashyap7x said:
Would this get much easier if edges were pre-oriented?

You mean, ZBLL? I actually think in general edges oriented cases will be worse than the rest of the set.

Although I think after finishing this (huge) task it would be cool for the community to help Kir generate and optimise a set of algs for ZBLL

Developing a better LL system

blindmod

Forever Slow

Veteran

Veteran

Colourful

Veteran

Veteran

statue

Colourful

Veteran

Premium Member

Premium Member

Veteran

Veteran

Colourful

Premium Member

Veteran

Colourful

Member

Babby

Similar threads