Developing a better LL system

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.
 
Last edited:
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).
 
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).
Click to expand...

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 ;)
Click to expand...

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 ;)
Click to expand...

<3

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?
Click to expand...

Because doing TPerm then Sune is better than doing COLL then EPLL?
 
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.
 
MaeLSTRoM made an image of the 'evil' cases;

OLnj0.jpg


Some are the same, I think he circled mirrors or something idk.
 
Kirjava said:
Setup: F R D2 F' R2 U B' R2 B U' R2 F D2 R' F' U
Click to expand...

(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'
 
Last edited:
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.
 
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.
 
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.
Click to expand...

in each box is different algs for one case. THe recog system is being worked on, it's gonna take some time.
 
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 ...
 
Last edited:
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.
Click to expand...

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?
Click to expand...

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:
Click to expand...

Yeah, I just didn't incorporate the removal of things like that in the solver. Some duplication was removed, but not all of it.
 
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.
Click to expand...
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.
Click to expand...

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?
 
Godmil said:
So how many cases roughly do you think people will need to memorise?
Click to expand...

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.
Click to expand...

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?
Click to expand...

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?
Click to expand...

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'.
 
Last edited by a moderator:
kashyap7x said:
Would this get much easier if edges were pre-oriented?
Click to expand...

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 :P
 
You must log in or register to reply here.

Similar threads

abunickabhi
Developing safety mentality for blind events
Replies
2
Views
577
Deleted member 36445
D
rebuC
Tips for developing simultaneous turning?
Replies
0
Views
548
rebuC
rebuC
SilkCubingYT
Mick's Progression Thread // Grinding clock and developing cubing software!! // Road to NR
Replies
8
Views
2,284
SilkCubingYT
SilkCubingYT
K
developing center-safe CLL/ELL for 3x3 shape mods
Replies
7
Views
1,318
SenorJuan
SenorJuan
Hucklebberry
  • Poll Poll
Developing my own solutions
Replies
3
Views
958
shadowslice e
shadowslice e
Back
Top