Rubik.Cube.Cubie.Internal

Documentation

newtype CornerPermu

Cubie permutation is in replaced-by representation.

Constructors

CornerPermu

Fields

fromCornerPermu :: Vector Int

Instances

Eq CornerPermu

Show CornerPermu

Monoid CornerPermu

Group CornerPermu

CubeAction CornerPermu

FromCube CornerPermu

RawEncodable CornerPermu

The number of elements of every set is given.

8! = 40320

newtype CornerOrien

Constructors

CornerOrien

Fields

fromCornerOrien :: Vector Int

Instances

Eq CornerOrien

Show CornerOrien

CubeAction CornerOrien

FromCube CornerOrien

RawEncodable CornerOrien

3^7 = 2187

data Corner

Constructors

Corner

Fields

cPermu :: CornerPermu

cOrien :: CornerOrien

Instances

Eq Corner

Show Corner

Monoid Corner

Group Corner

CubeAction Corner

FromCube Corner

cornerPermu :: Vector Int -> Maybe CornerPermu

Check that the argument is a permutation of size 8 and wrap it.

In a solvable Rubik's cube, its parity must be equal to that of the associated EdgePermu.

unsafeCornerPermu :: Vector Int -> CornerPermu

unsafeCornerPermu' :: [Int] -> CornerPermu

cornerOrien :: Vector Int -> Maybe CornerOrien

Check that the argument is a vector of senary (6) values of size 8 and wrap it.

In a solvable Rubik's cube, only ternary values are possible; i.e., all elements must be between 0 and 2. Their sum must also be a multiple of 3.

Orientation encoding

Corner orientations are permutations of 3 facelets.

They are mapped to integers in [0 .. 5] such that [0, 1, 2] are rotations (even permutations) and [3, 4, 5] are transpositions (although impossible in a Rubik's cube).

• 0. identity
• 1. counter-clockwise
• 2. clockwise
• 3. left facelet fixed
• 4. right facelet fixed
• 5. top (reference) facelet fixed

unsafeCornerOrien :: Vector Int -> CornerOrien

unsafeCornerOrien' :: [Int] -> CornerOrien

newtype EdgePermu

Cubie permutation is in replaced-by representation.

Constructors

EdgePermu

Fields

fromEdgePermu :: Vector Int

Instances

Eq EdgePermu

Show EdgePermu

Monoid EdgePermu

Group EdgePermu

CubeAction EdgePermu

FromCube EdgePermu

RawEncodable EdgePermu

12! = 479001600

A bit too much to hold in memory.

Holds just right in a Haskell Int (maxInt >= 2^29 - 1).

newtype EdgeOrien

Constructors

EdgeOrien

Fields

fromEdgeOrien :: Vector Int

Instances

Eq EdgeOrien

Show EdgeOrien

CubeAction EdgeOrien

FromCube EdgeOrien

RawEncodable EdgeOrien

2^11 = 2048

data Edge

Constructors

Edge

Fields

ePermu :: EdgePermu

eOrien :: EdgeOrien

Instances

Eq Edge

Show Edge

Monoid Edge

Group Edge

CubeAction Edge

FromCube Edge

edgePermu :: Vector Int -> Maybe EdgePermu

Check that the argument is a permutation of size 12 and wrap it.

In a solvable Rubik's cube, its parity must be equal to that of the associated CornerPermu.

unsafeEdgePermu :: Vector Int -> EdgePermu

unsafeEdgePermu' :: [Int] -> EdgePermu

edgeOrien :: Vector Int -> Maybe EdgeOrien

Check that the argument is a vector of binary values of size 12 and wrap it.

In a solvable Rubik's cube, their sum must be even.

unsafeEdgeOrien :: Vector Int -> EdgeOrien

unsafeEdgeOrien' :: [Int] -> EdgeOrien

data Cube

A cube is given by the positions of its corners and edges.

Cubes are identified with the permutations that produce them starting from the solved cube.

The cube permutation composition (class Group Cube) is defined "in left to right order", so that the sequence of movements "x then y then z" is represented by x <> y <> z.

Constructors

Cube

Fields

corner :: Corner

edge :: Edge

Instances

Eq Cube

Show Cube

Monoid Cube

Group Cube

class FromCube a where

Methods

fromCube :: Cube -> a

Instances

FromCube UDEdgePermu2

FromCube UDSlicePermu2

FromCube UDSlice

FromCube UDSlicePermu

FromCube Edge

FromCube EdgeOrien

FromCube EdgePermu

FromCube Corner

FromCube CornerOrien

FromCube CornerPermu

(FromCube a, FromCube b) => FromCube (a, b)

class CubeAction a where

Group action of Cube on type a

 x `cubeAction` iden == x
(x `cubeAction` a) `cubeAction` b == x `cubeAction (a <> b)

It seems that with proper additional laws between FromCube and Group instances, it may be possible to automatically deduce a default CubeAction instance.

cubeAction a = (a <>) . fromCube

This module defines representations of right cosets (Hg where g :: Cube) of certain subgroups H of the Rubik group Cube, which acts on the right of the set of cosets.

Methods

cubeAction :: a -> Cube -> a

Instances

CubeAction UDEdgePermu2

CubeAction UDSlicePermu2

CubeAction UDSlice

CubeAction UDSlicePermu

CubeAction Edge

CubeAction EdgeOrien

CubeAction EdgePermu

CubeAction Corner

CubeAction CornerOrien

CubeAction CornerPermu

(CubeAction a, CubeAction b) => CubeAction (a, b)

cube :: Vector Int -> Vector Int -> Vector Int -> Vector Int -> Maybe Cube

cube' :: [Int] -> [Int] -> [Int] -> [Int] -> Maybe Cube

unsafeCube :: Vector Int -> Vector Int -> Vector Int -> Vector Int -> Cube

unsafeCube' :: [Int] -> [Int] -> [Int] -> [Int] -> Cube

numCorners :: Int

numCorners = 8

numEdges :: Int

numEdges = 12

oPlus :: Integral a => a -> a -> a

oInv :: (Num a, Ord a) => a -> a

actionCorner :: CornerOrien -> Corner -> CornerOrien

actionEdge :: EdgeOrien -> Edge -> EdgeOrien

solvable :: Cube -> Bool

Tests whether a cube can be solved with the standard set of moves.

symRotate :: Int -> [Int] -> [Int]

0 <= o < 6

toFacelet :: Cube -> Facelets

colorFaceletsToCube :: ColorFacelets -> Either [Int] (Maybe Cube)

Convert from facelet to cubie permutation.

Evaluates to a Left error if a combination of colors does not correspond to a regular cubie from the solved cube: the colors of the facelets on one cubie must be unique, and must not contain facelets of opposite faces. The error is the list of indices of facelets of such an invalid cubie.

Another possible error is that the resulting configuration is not a permutation of cubies (at least one cubie is absent, and one is duplicated). In that case, the result is Right Nothing.

stringOfCubeColors :: Cube -> String

UDSlice

newtype UDSlicePermu

Position of the 4 UDSlice edges (carried-to)

Constructors

UDSlicePermu

Fields

fromUDSlicePermu :: Vector Int

Instances

Eq UDSlicePermu

Show UDSlicePermu

CubeAction UDSlicePermu

FromCube UDSlicePermu

RawEncodable UDSlicePermu

12! / 8! = 11880

newtype UDSlice

Position of the 4 UDSlice edges up to permutation (carried-to). The vector is always sorted.

Constructors

UDSlice

Fields

fromUDSlice :: Vector Int

Instances

Eq UDSlice

Show UDSlice

CubeAction UDSlice

FromCube UDSlice

RawEncodable UDSlice

12C4 = 495

newtype UDSlicePermu2

Position of the 4 UDSlice edges (replaced-by), assuming they are all in that slice already.

Constructors

UDSlicePermu2

Fields

fromUDSlicePermu2 :: Vector Int

Instances

Eq UDSlicePermu2

Show UDSlicePermu2

CubeAction UDSlicePermu2

FromCube UDSlicePermu2

RawEncodable UDSlicePermu2

4! = 24

newtype UDEdgePermu2

Position of the 8 other edges (replaced-by), assuming UDSlice edges are in that slice already.

Constructors

UDEdgePermu2

Fields

fromUDEdgePermu2 :: Vector Int

Instances

Eq UDEdgePermu2

Show UDEdgePermu2

CubeAction UDEdgePermu2

FromCube UDEdgePermu2

RawEncodable UDEdgePermu2

8! = 40320

type FlipUDSlice = (UDSlice, EdgeOrien)

type FlipUDSlicePermu = (UDSlicePermu, EdgeOrien)

numUDSliceEdges :: Int

numUDSliceEdges = 4

unsafeUDSlicePermu :: Vector Int -> UDSlicePermu

unsafeUDSlicePermu' :: [Int] -> UDSlicePermu

uDSlicePermu :: Vector Int -> Maybe UDSlicePermu

uDSlice :: Vector Int -> Maybe UDSlice

Wrap an increasing list of 4 elements in [0 .. 11].

unsafeUDSlice :: Vector Int -> UDSlice

unsafeUDSlice' :: [Int] -> UDSlice

uDSlicePermu2 :: Vector Int -> Maybe UDSlicePermu2

Wrap a permutation of size 4.

unsafeUDSlicePermu2 :: Vector Int -> UDSlicePermu2

unsafeUDSlicePermu2' :: [Int] -> UDSlicePermu2

uDEdgePermu2 :: Vector Int -> Maybe UDEdgePermu2

Wrap a permutation of size 8.

unsafeUDEdgePermu2 :: Vector Int -> UDEdgePermu2

unsafeUDEdgePermu2' :: [Int] -> UDEdgePermu2

vSort :: Vector Int -> Vector Int

unpermuUDSlice :: UDSlicePermu -> UDSlice

edgePermu2 :: UDSlicePermu2 -> UDEdgePermu2 -> EdgePermu

neutralUDSlicePermu :: UDSlicePermu

neutralUDSlice :: UDSlice

neutralUDSlicePermu2 :: UDSlicePermu2

neutralUDEdgePermu2 :: UDEdgePermu2

actionUDSlicePermu' :: EdgePermu -> Vector Int -> Vector Int

actionUDSlicePermu :: UDSlicePermu -> EdgePermu -> UDSlicePermu

actionUDSlice :: UDSlice -> EdgePermu -> UDSlice

actionUDSlicePermu2 :: UDSlicePermu2 -> EdgePermu -> UDSlicePermu2

actionUDEdgePermu2 :: UDEdgePermu2 -> EdgePermu -> UDEdgePermu2

conjugateFlipUDSlice :: Cube -> FlipUDSlice -> FlipUDSlice

The conjugation is only compatible when the Cube symmetry leaves UDSlice edges stable, and either flips them all or none of them, and either flips all 8 non-UDSlice edges or none of them.

conjugateFlipUDSlicePermu :: Cube -> FlipUDSlicePermu -> FlipUDSlicePermu

Expects UDSlice-stable symmetry

conjugateEdgeOrien' :: Cube -> FlipUDSlicePermu -> EdgeOrien

conjugateUDSlicePermu :: Cube -> UDSlicePermu -> UDSlicePermu

conjugateCornerOrien :: Cube -> CornerOrien -> CornerOrien

Expects UDSlice-stable symmetry.