def main(count_type=count_type):
    assert count_type in ['decisions', 'actions']

    effects = []
    lengths = []
    for length in tqdm(range(1, 41)):
        n_trials = 100
        effect = 0
        for trial in range(n_trials):
            d = cube.Cube()
            f = random_action_skill(length)
            d.apply(f)
            effect += len(d.summarize_effects())
        lengths.append(length)
        effects.append(effect / n_trials)
    lengths = [l - 0.1 for l in lengths]
    plt.scatter(lengths, effects, marker='^', label='Primitive Actions')

    effects = []
    lengths = []
    for length in tqdm(range(1, 41)):
        n_trials = 50
        effect = 0
        n_actions = 0
        for trial in range(n_trials):
            d = cube.Cube()
            o_seq, m_seq = random_option_skill(length)
            for o, m in zip(o_seq, m_seq):
                n_actions += len(o)
                d.apply(swap_list=m)
            effect += len(d.summarize_effects())
        if count_type == 'actions':
            lengths.append(n_actions / n_trials)  # count actions
        else:
            lengths.append(length)  # count options
        effects.append(effect / n_trials)
    lengths = [l for l in lengths]
    plt.scatter(lengths, effects, marker='o', label='Options')

    x_max = 40 if count_type == 'decisions' else 500
    plt.hlines(48, 0, x_max, linestyles='dotted')
    plt.legend(loc='lower right')
    plt.title('Average number of squares modified by sequence')
    plt.xlabel('Number of {} per sequence'.format(count_type))
    plt.ylim([0, 50])
    if count_type == 'actions':
        plt.xlim([0, 500])
    plt.show()
Example #2
0
def import_cube(data: list) -> cube.Cube:
    """ Returns a cube, given a length 54 list. """
    c = [cube.list_mat(data[:9])] + [[data[i:i + 3] for i in range(j, 43, 12)] for j in range(9, 21, 3)] + [cube.list_mat(data[-9:])]

    obj = cube.Cube()
    obj.cube = cube.str_cubies(c)
    return obj
Example #3
0
class expert:
    alg_formulas = [
        skills.swap_3_edges_face,
        skills.swap_3_edges_mid,
        skills.swap_3_corners,
        skills.orient_2_edges,
        skills.orient_2_corners,
    ]
    options = [
        variation for f in alg_formulas for variation in formula.variations(f)
    ]
    models = [cube.Cube().apply(o).summarize_effects() for o in options]
Example #4
0
import copy
import random
from tqdm import tqdm

from cube import cube
from cube import formula
from cube import skills
from cube import options
from cube import pattern

c = cube.Cube()
c.apply(pattern.scramble1)
c.render()

#%%
mods = c.summarize_effects()
steps = []
experiences = 0
tqdm.write('experiences:{}--steps:{}--errors:{}'.format(experiences, len(steps),len(mods)))

option_set = options.expert

max_depth = 2
def option_sequences(depth, prefix=None):
    assert depth > 0, 'Depth must be > 0'
    options = [o for o in random.sample(option_set.options, len(option_set.options))]
    if depth==1:
        return [[o] if prefix==None else prefix+[o] for o in options]
    else:
        new_prefixes = [[o] if prefix==None else prefix+[o] for o in options]
        result = []
import copy
import matplotlib.pyplot as plt
import random
from tqdm import tqdm
from collections import namedtuple

from cube import cube
from cube import formula
from cube import skills
from cube import options
from cube import pattern

c = cube.Cube()
c.render()

Skill = namedtuple('Skill', ['seq', 'mdl'])


def combine_skills(skills, depth, prefix=None):
    assert depth > 0, 'Depth must be > 0'
    # skills = [s for s in random.sample(skills, len(skills))]
    if depth == 1:
        seqs = [
            s.seq if prefix == None else formula.simplify(prefix.seq + s.seq)
            for s in skills
        ]
        mdls = [
            s.mdl if prefix == None else cube.combine_swaps(prefix.mdl, s.mdl)
            for s in skills
        ]
        return [
for f in cube_files:
    seed = int(f.split('/')[-1].split('.')[-2].split('-')[-1])
    with open(f, 'rb') as f:
        cubefail = pickle.load(f)
    if seed in [8]:#[1,8,14,35,53,76,100]:
        print(seed)
        cubefail.render()
        break
    pass

#%%
cube_mod = copy.deepcopy(cubefail)
rot = formula.rotate

cube_mod.apply("R R".split())
cube_mod.apply(rot(rot("F F R' F' U' F' U F R F' U U F U U F' U'".split(),cube.Face.L,2),cube.Face.D,2))
cube_mod.apply("R R".split())

# cube_mod.apply("D' F".split())
# cube_mod.apply(rot("F F R' F' U' F' U F R F' U U F U U F' U'".split(),cube.Face.U))
# cube_mod.apply(formula.inverse(rot(skills.orient_2_corners,cube.Face.U)))
# cube_mod.apply("F' D".split())

cube_mod.render()

#%%
newcube = cube.Cube()
newcube.apply(rot(rot("F F R' F' U' F' U F R F' U U F U U F' U'".split(),cube.Face.L,0),cube.Face.D,0))
newcube.render()
# len(newcube.summarize_effects())
Example #7
0
def mult(l1: list, l2: list) -> list:
    """ Applies permutation l2 to l1. """
    return [l1[n] for n in l2]


if __name__ == "__main__":
    ### U move written as other moves
    # c = cube.Cube()
    # c.turn("U")
    # noU = cube.Metric(cube.mat_list(((move, move + "'", move + "2") for move in "DFBRL")))
    # print(cube.IDsolve(c, metric=noU)[:-1])
    # exit()

    ### 3x3 with double move algs
    c = cube.Cube()
    ## four edge cycles
    # c.turn("M2 U2 M2 U2 z M2 U2 M2 U2 z'")
    # c.turn("M' U2 M2 U2 M' y M' U2 M2 U2 M' y'")
    # c.turn("M2 U2 M2 U2 z M2 U2 M2 U2 z' x M2 U' M2 U2 M2 U' M2 x'")
    # c.turn("M' U2 M2 U2 M' y M' U2 M2 U2 M' y' M2 U' M2 U2 M2 U' M2")
    # c.turn("M' U2 M2 U2 M' y M' U2 M2 U2 M' y' x2 M2 U' M2 U2 M2 U' M2 x2")

    print(c)
    print(cube.solve(c, metric=cube.HALF)[:-1])
    exit()

    print(mult(["a", "b", "c", "d", "e"], [2, 4, 0, 1, 3]))

    ### TESTING GENERATION AND EQUAL TO MOVE
Example #8
0
class random:
    alg_formulas = [skills.random_skill(len(a)) for a in expert.alg_formulas]
    options = [
        variation for f in alg_formulas for variation in formula.variations(f)
    ]
    models = [cube.Cube().apply(o).summarize_effects() for o in options]
import matplotlib.pyplot as plt
from tqdm import tqdm

from cube import cube
from cube import skills as random_skills

#%%
effects = []
lengths = []
short_skills = []
for length in tqdm(range(1, 25)):
    n_trials = 1000
    effect = 0
    for trial in range(n_trials):
        d = cube.Cube()
        f = random_skills.random_skill(length)
        d.apply(f)
        effect = len(d.summarize_effects())
        if effect < 20:
            short_skills.append(f)
            if f:
                tqdm.write('moves={}; effect={}; seq={}'.format(
                    len(f), effect, ' '.join(f)))
        lengths.append(len(f))
        effects.append(effect)
lengths = [l - 0.1 for l in lengths]

plt.scatter(lengths, effects, marker='o', label='Random')

#%%
effects = []
import copy
from cube import cube
from notebooks import astar

start = cube.Cube()
newcube = copy.deepcopy(start)
newcube.transform('R')
newcube.render()
start.render()

is_goal = lambda cube: cube == cube.Cube()
heuristic = lambda cube: len(cube.summarize_effects())


def get_successors(cube):
    [copy.deepcopy(cube).transform(a) for a in cube.Action.keys]


astar.search(start, is_goal, 1, heuristic, get_successors)
import cube.cube as cube

# example of a reconstruction
# 41 HTM/5.44 = 7.54 TPS done while talking about railgun
c = cube.Cube()
c.turn("L2 U B U B' L F B' L' R2 D2 L2 F2 B2 U R2 F2 U2 B2 U L")  # scramble
c.turn("x2 y")  # inspection
c.turn("L F' D' R' D")  # cross
c.turn("y U R U R' L U' L'")  # 1st pair
c.turn("U2 R' U' R U' R' U R")  # 2nd pair
c.turn("y' U2 R' U' R")  # 3rd pair
c.turn("U2 R U' R' U R U' R'")  # 4th pair
c.turn("U' R U R' U R U2 R'")  # OLL + PLL skip
c.turn("U'")  # AUF
print(c)

# last 2 pairs + LL is 2gen
# what if I did it optimally?
c = cube.Cube()
c.turn("L2 U B U B' L F B' L' R2 D2 L2 F2 B2 U R2 F2 U2 B2 U L")  # scramble
c.turn("x2 y")  # inspection
c.turn("L F' D' R' D")  # cross
c.turn("y U R U R' L U' L'")  # 1st pair
c.turn("U2 R' U' R U' R' U R")  # 2nd pair
c.turn("y'")
print(c)

goal = cube.Cube()
goal.turn("x2 y")
sol = cube.solve(c, target=(goal, cube.solved), metric=cube.TGEN)[1]
print(sol, len(cube.tokenize(sol)))