Thread: "Notation and turn metrics for the 2x2x2x2"

From: Melinda Green <melinda@superliminal.com>
Date: Fri, 14 Sep 2018 19:14:06 -0700
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2



--------------BBDD6E0B751937CADDF99B17
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable

This all sounds great to me. Comments in-line.

On 9/13/2018 2:19 PM, Andrew Farkas ajfarkas12@gmail.com [4D_Cubing] wrote:
>
> Hey everyone!
>
> I've been working on the random-state scrambler/solver and discussing thi=
ngs with Marc over the past few days, and I've come up with some things tha=
t I think are worth sharing.
>
> Notation
> I've yet to see a proper compendium of notation for the 2^4, so here's my=
proposal for moves in the horizontal orientation:
>
> * A face *R*, *L*, *I*, or *O*, followed by one of the following:
> o Any letter *r*, *l*, *u*, *d*, *f*, *b*, *x*, *y*, *z*=C2=A0(plus=
an optional *'*=C2=A0or *2*).
>

I get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instance =
I get *Rz *but not *Ru*.

> o A pair of square brackets containing any sequence of 3D moves tps://www.speedsolving.com/wiki/index.php/Notation> that are valid on a 2x2=
x2.
> + Most of the time, of course, these moves should be 0-mod-4.
> * The moves *U2*, *D2*, *F2*, and *B2*.
> * The full puzzle rotations *x*, *x'*, *x2*, *y2*, and *z2*.
> * The stacking moves *M*, *M'*, *M2*, *E*, and *S*.
> o *M*=C2=A0moves the right endcap over to the left of the puzzle; *=
M'*=C2=A0does the opposite, and *M2*=C2=A0swaps the left and right halves o=
f the puzzle.
> o *E*=C2=A0swaps the top and bottom halves of the puzzle.
> o *S*=C2=A0swaps the front and back halves of the puzzle.
>

Sounds fine though where did the names *M*, *E*, and *S *come from? I proba=
bly just missed it, but I need mnemonics for them. Or maybe something a lit=
tle more self-descriptive might help, like *Sd *where *S *means "Stack" and=
'd' is the direction *x, y, *or *z*. Or following your '*clam*' suggestion=
, they could be *x stack*, *y' stack*, etc.

> * *z clam* and *z' clam*.
> o *z clam*=C2=A0is a *z*=C2=A0rotation followed by a clamshell move=
.
> o *z' clam*=C2=A0is a *z'*=C2=A0rotation followed by a clamshell mo=
ve.
> o *z clam*=C2=A0and *z' clam*=C2=A0are inverses.
>
> * Parentheses can be used for grouping, and numbers can follow parenthe=
ses to repeat a sequence.
> * Commutator notation utators_and_Conjugates> is allowed when useful.
>
> The use of lowercase letters in moves like *Rr*=C2=A0may be controversial=
; if they are deemed confusing, *R[R]*=C2=A0could be encouraged instead.
>
> Here's an equivalent of Melinda's original gyro sequence in this notation=
:
> *M E z' clam (x z' clam)2 *
>

It's nice that you included the clamshell move but does it belong here sinc=
e we decided to not call it canonical? Maybe we could use some form of macr=
o notation for naming sequences built from canonical moves and previously d=
efined sequences. For instance perhaps I could define

*let clam =3D R2 U2 R2*

and then use *clam *and *clam'* wherever I like. Someone following my seque=
nces would be free to use the above canonical moves or perform the clamshel=
l move as a shortcut since the results are identical. I could then define m=
y gyro as

*let gyro =3D M E clam**(x clam')2*

And of course if someone prefers a different gyro move they can just use th=
at since again the results are identical. Or is this all just overkill?

> I'll briefly digress to discuss a WCA-inspired ciation.org/regulations/#4d1> "standard orientation" that Marc and I have b=
een using. WCA regulations state that white face should be on top (Y axis) =
and the green face should be on the front (Z axis). On a standard NxNxN, th=
is will result in the red face on the right (X axis). [...]
>

Makes sense.

>
> Metric
> As for counting numbers of moves, I'd like to propose the "snap" metric. =
Each separation and reattachment of pieces is a single move.. This can be v=
ery dependent on how a move is executed, but I think it makes the most sens=
e for the purpose of solving and speedsolving.
>
> A single move like *Iy*=C2=A0could be executed in three snaps as *M Ry M'=
*=C2=A0or in just two snaps by rearranging the right and left endcaps aroun=
d the *I*=C2=A0layer. A sequence like *x' Rz Lz' M2*=C2=A0may seem like a l=
ot of moves, but it can be executed in one snap. (The *x'*=C2=A0is actually=
zero snaps, regardless of context.) The sequence *z' clam*=C2=A0is two sna=
ps, while the equivalent *Rx2 U2 (R[x2 y'] Ly)*=C2=A0is three snaps. *Ix*=
=C2=A0can be executed as three snaps with *M Rx M'*, two snaps with *Rr Ll'=
x'*, or one snap by holding the endcaps with one hand and rotating the *I*=
=C2=A0layer with the other. (In an actual solve, the two-snap method is pro=
bably fastest.) While *Rr*=C2=A0is pretty clearly one snap, *Ru*=C2=A0could=
be executed in two snaps (by separating the left and right halves, perform=
ing *Ru*, and then reattaching them) or one snap (by removing the four piec=
es of *Ru*=C2=A0directly, rotating them, and replacing them).

I like the snap metric a lot for quantifying the amount of work or physical=
complexity of some sequence. I don't know if it makes sense to use for few=
est-moves contests for example, but it could be very helpful for comparing =
and streamlining algorithms.

-Melinda

--------------BBDD6E0B751937CADDF99B17
Content-Type: text/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable



">


This all sounds great to me. Comments in-line.



On 9/13/2018 2:19 PM, Andrew Farkas
.com">ajfarkas12@gmail.com [4D_Cubing] wrote:


cite=3D"mid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail.=
com">
-8">











Hey everyone!




I've been working on
the random-state scrambler/solver and
discussing things with Marc over the past few
days, and I've come up with some things that I
think are worth sharing.




Notat=
ion

I've yet to see a
proper compendium of notation for the 2^4, so
here's my proposal for moves in the horizontal
orientation:



  • A face R, L, I,
    or O, followed by one of the
    following:



    • Any letter=C2=A0r, l,=C2=A0=
      u,=C2=A0d,=C2=A0f,=C2=A0b,=C2=A0x,=C2=A0=
      y,=C2=A0z=C2=A0(plus
      an optional '=C2=A0or 2).>















I get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For
instance I get Rz but not Ru.



cite=3D"mid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail.=
com">












    • A pair of square brackets containing
      any sequence of href=3D"https://www.speedsolving.com/wiki=
      /index.php/Notation"
      target=3D"_blank" moz-do-not-send=3D"true=
      ">3D
      moves that are valid on a 2x2x2.


      • Most of the time, of course, these
        moves should be 0-mod-4.



  • The moves U2, D2, F2,
    and=C2=A0B2.


  • The full puzzle rotations x, x'b>,
    x2, y2, and z2.

  • The stacking moves M, M',
    M2, E, and S.


    • M=C2=A0moves the right endcap over
      to the left of the puzzle; M'=C2=A0d=
      oes
      the opposite, and M2=C2=A0swaps the
      left and right halves of the puzzle.

    • E=C2=A0swaps the top and bottom
      halves of the puzzle.

    • S=C2=A0swaps the front and back
      halves of the puzzle.
















Sounds fine though where did the names M, E, and S
come from? I probably just missed it, but I need mnemonics for
them. Or maybe something a little more self-descriptive might help,
like Sd where S means "Stack" and 'd' is the
direction x, y, or z. Or following your 'clam'
suggestion, they could be x stack, y' stack, etc.



cite=3D"mid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail.=
com">











  • z clam and z' clam.


    • z clam=C2=A0is a=C2=A0z=C2=
      =A0rotation
      followed by a clamshell move.

    • z' clam=C2=A0is a z'=C2=A0r=
      otation
      followed by a clamshell move.

    • z clam=C2=A0and z' clam=C2=
      =A0are
      inverses.














cite=3D"mid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail.=
com">











  • Parentheses can be used for grouping,
    and numbers can follow parentheses to
    repeat a sequence.

  • href=3D"https://www.speedsolving.com/wiki/index.php/Commutators_and_Conjuga=
    tes"
    target=3D"_blank" moz-do-not-send=3D"true">=
    Commutator
    notation is allowed when useful.


The use of lowercase letters in moves
like Rr=C2=A0may be controversial; if
they are deemed confusing,=C2=A0R[R]=C2=
=A0could
be encouraged instead.




Here's an equivalent of Melinda's
original gyro sequence in this notation:

M E z' clam (x z' clam)2=C2=A0

















It's nice that you included the clamshell move but does it belong
here since we decided to not call it canonical? Maybe we could use
some form of macro notation for naming sequences built from
canonical moves and previously defined sequences. For instance
perhaps I could define

let clam =3D R2 U2 R2


and then use clam and clam' wherever I like.
Someone following my sequences would be free to use the above
canonical moves or perform the clamshell move as a shortcut since
the results are identical. I could then define my gyro as

let gyro =3D M E clam (x clam')2


And of course if someone prefers a different gyro move they can just
use that since again the results are identical. Or is this all just
overkill?



cite=3D"mid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail.=
com">










I'll briefly digress to discuss a href=3D"https://www.worldcubeassociation.org/=
regulations/#4d1"
target=3D"_blank" style=3D""
moz-do-not-send=3D"true">WCA-inspired
"standard orientation" that Marc and I have
been using. WCA regulations state that white
face should be on top (Y axis) and the green
face should be on the front (Z axis). On a
standard NxNxN, this will result in the red
face on the right (X axis). [...]

















Makes sense.



cite=3D"mid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail.=
com">













Metric

As for counting numbers of moves, I'd
like to propose the "snap" metric. Each
separation and reattachment of pieces is a
single move.. This can be very dependent on
how a move is executed, but I think it makes
the most sense for the purpose of solving
and speedsolving.




A single move like Iy=C2=A0could be
executed in three snaps as M Ry M'=C2=A0=
or
in just two snaps by rearranging the right
and left endcaps around the I=C2=A0layer=
.
A sequence like x' Rz Lz' M2=C2=A0may
seem like a lot of moves, but it can be
executed in one snap. (The x'=C2=A0is
actually zero snaps, regardless of context.)
The sequence z' clam=C2=A0is two snaps,
while the equivalent Rx2 U2 (R[x2 y']
Ly)=C2=A0is three snaps. Ix=C2=A0c=
an be
executed as three snaps with M Rx M',
two snaps with Rr Ll' x', or one
snap by holding the endcaps with one hand
and rotating the I=C2=A0layer with the
other. (In an actual solve, the two-snap
method is probably fastest.) While Rr=C2=
=A0is
pretty clearly one snap, Ru=C2=A0could b=
e
executed in two snaps (by separating the
left and right halves, performing Ru,
and then reattaching them) or one snap (by
removing the four pieces of Ru=C2=A0dire=
ctly,
rotating them, and replacing them).















I like the snap metric a lot for quantifying the amount of work or
physical complexity of some sequence. I don't know if it makes sense
to use for fewest-moves contests for example, but it could be very
helpful for comparing and streamlining algorithms.



-Melinda




--------------BBDD6E0B751937CADDF99B17--



From: "Eduard Baumann" <ed.baumann@bluewin.ch>
Date: Sat, 15 Sep 2018 09:59:48 +0200
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2



------=_NextPart_000_0018_01D44CDA.D85A3900
Content-Type: text/plain;
charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

M as middle
E as equator and
S as standing

Best regards
Ed


----- Original Message -----=20
From: Melinda Green melinda@superliminal.com [4D_Cubing]=20
To: 4D_Cubing@yahoogroups.com=20
Sent: Saturday, September 15, 2018 4:14 AM
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2


=20=20=20=20
This all sounds great to me. Comments in-line.



On 9/13/2018 2:19 PM, Andrew Farkas ajfarkas12@gmail.com [4D_Cubing] wrot=
e:

Hey everyone!


I've been working on the random-state scrambler/solver and discussing t=
hings with Marc over the past few days, and I've come up with some things t=
hat I think are worth sharing.


Notation
I've yet to see a proper compendium of notation for the 2^4, so here's =
my proposal for moves in the horizontal orientation:
a.. A face R, L, I, or O, followed by one of the following:

a.. Any letter r, l, u, d, f, b, x, y, z (plus an optional ' or 2).=
=20

I get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instanc=
e I get Rz but not Ru.


a.. A pair of square brackets containing any sequence of 3D moves t=
hat are valid on a 2x2x2.=20
a.. Most of the time, of course, these moves should be 0-mod-4.=20
a.. The moves U2, D2, F2, and B2.

b.. The full puzzle rotations x, x', x2, y2, and z2.=20
c.. The stacking moves M, M', M2, E, and S.=20
a.. M moves the right endcap over to the left of the puzzle; M' doe=
s the opposite, and M2 swaps the left and right halves of the puzzle.=20
b.. E swaps the top and bottom halves of the puzzle.=20
c.. S swaps the front and back halves of the puzzle.=20

Sounds fine though where did the names M, E, and S come from? I probably =
just missed it, but I need mnemonics for them. Or maybe something a little =
more self-descriptive might help, like Sd where S means "Stack" and 'd' is =
the direction x, y, or z. Or following your 'clam' suggestion, they could b=
e x stack, y' stack, etc.


a.. z clam and z' clam.=20
a.. z clam is a z rotation followed by a clamshell move.=20
b.. z' clam is a z' rotation followed by a clamshell move.=20
c.. z clam and z' clam are inverses.=20
a.. Parentheses can be used for grouping, and numbers can follow pare=
ntheses to repeat a sequence.=20
b.. Commutator notation is allowed when useful.=20
The use of lowercase letters in moves like Rr may be controversial; if =
they are deemed confusing, R[R] could be encouraged instead.


Here's an equivalent of Melinda's original gyro sequence in this notati=
on:
M E z' clam (x z' clam)2=20



It's nice that you included the clamshell move but does it belong here si=
nce we decided to not call it canonical? Maybe we could use some form of ma=
cro notation for naming sequences built from canonical moves and previously=
defined sequences. For instance perhaps I could define

let clam =3D R2 U2 R2

and then use clam and clam' wherever I like. Someone following my sequenc=
es would be free to use the above canonical moves or perform the clamshell =
move as a shortcut since the results are identical. I could then define my =
gyro as

let gyro =3D M E clam (x clam')2

And of course if someone prefers a different gyro move they can just use =
that since again the results are identical. Or is this all just overkill?


I'll briefly digress to discuss a WCA-inspired "standard orientation" t=
hat Marc and I have been using. WCA regulations state that white face shoul=
d be on top (Y axis) and the green face should be on the front (Z axis). On=
a standard NxNxN, this will result in the red face on the right (X axis). =
[...]



Makes sense.




Metric
As for counting numbers of moves, I'd like to propose the "snap" metric=
. Each separation and reattachment of pieces is a single move.. This can be=
very dependent on how a move is executed, but I think it makes the most se=
nse for the purpose of solving and speedsolving.


A single move like Iy could be executed in three snaps as M Ry M' or in=
just two snaps by rearranging the right and left endcaps around the I laye=
r.. A sequence like x' Rz Lz' M2 may seem like a lot of moves, but it can b=
e executed in one snap. (The x' is actually zero snaps, regardless of conte=
xt.) The sequence z' clam is two snaps, while the equivalent Rx2 U2 (R[x2 y=
'] Ly) is three snaps. Ix can be executed as three snaps with M Rx M', two =
snaps with Rr Ll' x', or one snap by holding the endcaps with one hand and =
rotating the I layer with the other. (In an actual solve, the two-snap meth=
od is probably fastest.) While Rr is pretty clearly one snap, Ru could be e=
xecuted in two snaps (by separating the left and right halves, performing R=
u, and then reattaching them) or one snap (by removing the four pieces of R=
u directly, rotating them, and replacing them).


I like the snap metric a lot for quantifying the amount of work or physic=
al complexity of some sequence. I don't know if it makes sense to use for f=
ewest-moves contests for example, but it could be very helpful for comparin=
g and streamlining algorithms.

-Melinda


=20=20
------=_NextPart_000_0018_01D44CDA.D85A3900
Content-Type: text/html;
charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

=EF=BB=BF




M as middle

E as equator  and

S as standing

 

Best regards

Ed

 

 

style=3D"BORDER-LEFT: #000000 2px solid; PADDING-LEFT: 5px; PADDING-RIGHT: =
0px; MARGIN-LEFT: 5px; MARGIN-RIGHT: 0px">
----- Original Message -----

style=3D"FONT: 10pt arial; BACKGROUND: #e4e4e4; font-color: black">Fro=
m:=20
href=3D"mailto:melinda@superliminal.com [4D_Cubing]">Melinda Green=20
melinda@superliminal.com [4D_Cubing]
To: ps.com=20
href=3D"mailto:4D_Cubing@yahoogroups.com">4D_Cubing@yahoogroups.com <=
/DIV>
Sent: Saturday, September 15, 2018=
4:14=20
AM

Subject: Re: [MC4D] Notation and t=
urn=20
metrics for the 2x2x2x2


 =20

This all sounds great to me. Comments in-line.


On 9/13/2018 2:19 PM, Andrew Farkas class=3Dmoz-txt-link-abbreviated=20
href=3D"mailto:ajfarkas12@gmail.com">ajfarkas12@gmail.com [4D_Cubing]=
=20
wrote:

cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">









Hey everyone!



I've been working on the random-state=20
scrambler/solver and discussing things with Marc over the past few days=
, and=20
I've come up with some things that I think are worth sharing.



Notation

I've yet to see a proper compendium of notat=
ion for=20
the 2^4, so here's my proposal for moves in the horizontal=20
orientation:



  • A face R, L, I, or O, followed by one=
    of=20
    the following:


    • Any letter r,=20
      l, u, d, f, b>, x, y, z (plus=20
      an optional ' or 2).=20
IV>

I=20
get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instance =
I get=20
Rz but not Ru.


cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">












    • A pair of square brackets containing any sequence of href=3D"https://www.speedsolving.com/wiki/index.php/Notation"=20
      target=3D_blank moz=3D"true">3D moves that are valid on a 2x2x2=
      .=20

      • Most of the time, of course, these moves should be 0-mod-4.=20

  • The moves U2, D2, F2, and B2.>
  • The full puzzle rotations x, x', x2, y2B>,=20
    and z2.=20
  • The stacking moves M, M', M2, E, and=
    =20
    S.=20

    • M moves the right endcap over to the left of the pu=
      zzle;=20
      M' does the opposite, and M2 swaps the left=
      and=20
      right halves of the puzzle.=20
    • E swaps the top and bottom halves of the puzzle.=20
    • S swaps the front and back halves of the puzzle.=20
<=
/DIV>

Sounds=20
fine though where did the names M, E, and S come fro=
m? I=20
probably just missed it, but I need mnemonics for them. Or maybe somethin=
g a=20
little more self-descriptive might help, like Sd where S me=
ans=20
"Stack" and 'd' is the direction x, y, or z. Or following y=
our=20
'clam' suggestion, they could be x stack, y' stack,=
=20
etc.


cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">











  • z clam and z' clam.=20

    • z clam is a z rotation followed by=
      a=20
      clamshell move.=20
    • z' clam is a z' rotation followed by a=
      =20
      clamshell move.=20
    • z clam and z' clam are inverses.=20
<=
/DIV>

cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">











  • Parentheses can be used for grouping, and numbers can follow=20
    parentheses to repeat a sequence.=20
  • href=3D"https://www.speedsolving.com/wiki/index.php/Commutators_and_C=
    onjugates"=20
    target=3D_blank moz=3D"true">Commutator notation is allowed when =
    useful.=20

The use of lowercase letters in moves like Rr may be=20
controversial; if they are deemed confusing, R[R] coul=
d be=20
encouraged instead.



Here's an equivalent of Melinda's original gyro sequence in this=20
notation:

M E z' clam (x z' clam)2 


DIV>
It's=20
nice that you included the clamshell move but does it belong here since w=
e=20
decided to not call it canonical? Maybe we could use some form of macro=20
notation for naming sequences built from canonical moves and previously=20
defined sequences. For instance perhaps I could define

let clam =3D R2 U2 R2
and then use =
clam=20
and clam' wherever I like. Someone following my sequences woul=
d be=20
free to use the above canonical moves or perform the clamshell move as a=
=20
shortcut since the results are identical. I could then define my gyro as<=
BR>
let gyro =3D M E clam (x clam')2
E>And=20
of course if someone prefers a different gyro move they can just use that=
=20
since again the results are identical. Or is this all just overkill?
<=
BR>
cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">










I'll briefly digress to discuss a href=3D"https://www.worldcubeassociation.org/regulations/#4d1" target=
=3D_blank=20
moz=3D"true">WCA-inspired "standard orientation" that Marc and I ha=
ve been=20
using. WCA regulations state that white face should be on top (Y axis) =
and=20
the green face should be on the front (Z axis). On a standard NxNxN, th=
is=20
will result in the red face on the right (X axis). [...]


DIV>

Makes=20
sense.


cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">












Metric

As for counting numbers of moves, I'd like to propose the "snap"=20
metric. Each separation and reattachment of pieces is a single move.. T=
his=20
can be very dependent on how a move is executed, but I think it makes t=
he=20
most sense for the purpose of solving and speedsolving.



A single move like Iy could be executed in three snaps=
as=20
M Ry M' or in just two snaps by rearranging the right and l=
eft=20
endcaps around the I layer.. A sequence like x' Rz Lz'=20
M2 may seem like a lot of moves, but it can be executed in one=
=20
snap. (The x' is actually zero snaps, regardless of context=
.)=20
The sequence z' clam is two snaps, while the equivalent =
Rx2=20
U2 (R[x2 y'] Ly) is three snaps. Ix can be execute=
d as=20
three snaps with M Rx M', two snaps with Rr Ll' x', or on=
e=20
snap by holding the endcaps with one hand and rotating the=20
I layer with the other. (In an actual solve, the two-snap m=
ethod=20
is probably fastest.) While Rr is pretty clearly one snap,=
=20
Ru could be executed in two snaps (by separating the left a=
nd=20
right halves, performing Ru, and then reattaching them) or one s=
nap=20
(by removing the four pieces of Ru directly, rotating them,=
and=20
replacing=20
them).
<=
/DIV>
I=20
like the snap metric a lot for quantifying the amount of work or physical=
=20
complexity of some sequence. I don't know if it makes sense to use for=20
fewest-moves contests for example, but it could be very helpful for compa=
ring=20
and streamlining algorithms.

-Melinda



------=_NextPart_000_0018_01D44CDA.D85A3900--



From: "Eduard Baumann" <ed.baumann@bluewin.ch>
Date: Sat, 15 Sep 2018 10:27:23 +0200
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2



------=_NextPart_000_0023_01D44CDE.B63ABB20
Content-Type: multipart/alternative;
boundary="----=_NextPart_001_0024_01D44CDE.B63ABB20"

------=_NextPart_001_0024_01D44CDE.B63ABB20
Content-Type: text/plain;
charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

More pictures for the notation for 2x2x2x2















Best regards
Ed

----- Original Message -----=20
From: Melinda Green melinda@superliminal.com [4D_Cubing]=20
To: 4D_Cubing@yahoogroups.com=20
Sent: Saturday, September 15, 2018 4:14 AM
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2


=20=20=20=20
This all sounds great to me. Comments in-line.



On 9/13/2018 2:19 PM, Andrew Farkas ajfarkas12@gmail.com [4D_Cubing] wrot=
e:

Hey everyone!


I've been working on the random-state scrambler/solver and discussing t=
hings with Marc over the past few days, and I've come up with some things t=
hat I think are worth sharing.


Notation
I've yet to see a proper compendium of notation for the 2^4, so here's =
my proposal for moves in the horizontal orientation:
a.. A face R, L, I, or O, followed by one of the following:

a.. Any letter r, l, u, d, f, b, x, y, z (plus an optional ' or 2).=
=20

I get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instanc=
e I get Rz but not Ru.


a.. A pair of square brackets containing any sequence of 3D moves t=
hat are valid on a 2x2x2.=20
a.. Most of the time, of course, these moves should be 0-mod-4.=20
a.. The moves U2, D2, F2, and B2.

b.. The full puzzle rotations x, x', x2, y2, and z2.=20
c.. The stacking moves M, M', M2, E, and S.=20
a.. M moves the right endcap over to the left of the puzzle; M' doe=
s the opposite, and M2 swaps the left and right halves of the puzzle.=20
b.. E swaps the top and bottom halves of the puzzle.=20
c.. S swaps the front and back halves of the puzzle.=20

Sounds fine though where did the names M, E, and S come from? I probably =
just missed it, but I need mnemonics for them. Or maybe something a little =
more self-descriptive might help, like Sd where S means "Stack" and 'd' is =
the direction x, y, or z. Or following your 'clam' suggestion, they could b=
e x stack, y' stack, etc.


a.. z clam and z' clam.=20
a.. z clam is a z rotation followed by a clamshell move.=20
b.. z' clam is a z' rotation followed by a clamshell move.=20
c.. z clam and z' clam are inverses.=20
a.. Parentheses can be used for grouping, and numbers can follow pare=
ntheses to repeat a sequence.=20
b.. Commutator notation is allowed when useful.=20
The use of lowercase letters in moves like Rr may be controversial; if =
they are deemed confusing, R[R] could be encouraged instead.


Here's an equivalent of Melinda's original gyro sequence in this notati=
on:
M E z' clam (x z' clam)2=20



It's nice that you included the clamshell move but does it belong here si=
nce we decided to not call it canonical? Maybe we could use some form of ma=
cro notation for naming sequences built from canonical moves and previously=
defined sequences. For instance perhaps I could define

let clam =3D R2 U2 R2

and then use clam and clam' wherever I like. Someone following my sequenc=
es would be free to use the above canonical moves or perform the clamshell =
move as a shortcut since the results are identical. I could then define my =
gyro as

let gyro =3D M E clam (x clam')2

And of course if someone prefers a different gyro move they can just use =
that since again the results are identical. Or is this all just overkill?


I'll briefly digress to discuss a WCA-inspired "standard orientation" t=
hat Marc and I have been using. WCA regulations state that white face shoul=
d be on top (Y axis) and the green face should be on the front (Z axis). On=
a standard NxNxN, this will result in the red face on the right (X axis). =
[...]



Makes sense.




Metric
As for counting numbers of moves, I'd like to propose the "snap" metric=
. Each separation and reattachment of pieces is a single move.. This can be=
very dependent on how a move is executed, but I think it makes the most se=
nse for the purpose of solving and speedsolving.


A single move like Iy could be executed in three snaps as M Ry M' or in=
just two snaps by rearranging the right and left endcaps around the I laye=
r.. A sequence like x' Rz Lz' M2 may seem like a lot of moves, but it can b=
e executed in one snap. (The x' is actually zero snaps, regardless of conte=
xt.) The sequence z' clam is two snaps, while the equivalent Rx2 U2 (R[x2 y=
'] Ly) is three snaps. Ix can be executed as three snaps with M Rx M', two =
snaps with Rr Ll' x', or one snap by holding the endcaps with one hand and =
rotating the I layer with the other. (In an actual solve, the two-snap meth=
od is probably fastest.) While Rr is pretty clearly one snap, Ru could be e=
xecuted in two snaps (by separating the left and right halves, performing R=
u, and then reattaching them) or one snap (by removing the four pieces of R=
u directly, rotating them, and replacing them).


I like the snap metric a lot for quantifying the amount of work or physic=
al complexity of some sequence. I don't know if it makes sense to use for f=
ewest-moves contests for example, but it could be very helpful for comparin=
g and streamlining algorithms.

-Melinda


=20=20
------=_NextPart_001_0024_01D44CDE.B63ABB20
Content-Type: text/html;
charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

=EF=BB=BF




More pictures for the notation for=20
2x2x2x2

 

3D""src=3D"cid:2E13950B024740CF91C85A667197EF91@LAB">

 

 

3D""src=3D"cid:C5FF98895457423FBA5386E1A464A75C@LAB">

 

 

3D""src=3D"cid:36134E8ECAFE4219AE033B8700C40667@LAB">

 

 

3D""src=3D"cid:98A62AA228614106BC6CCF0654448783@LAB">

 

 

3D""src=3D"cid:5124389D064245E09DD84DDFD9013FF4@LAB">

 

Best regards

Ed

 

style=3D"BORDER-LEFT: #000000 2px solid; PADDING-LEFT: 5px; PADDING-RIGHT: =
0px; MARGIN-LEFT: 5px; MARGIN-RIGHT: 0px">
----- Original Message -----

style=3D"FONT: 10pt arial; BACKGROUND: #e4e4e4; font-color: black">Fro=
m:=20
href=3D"mailto:melinda@superliminal.com [4D_Cubing]">Melinda Green=20
melinda@superliminal.com [4D_Cubing]

To: ps.com=20
href=3D"mailto:4D_Cubing@yahoogroups.com">4D_Cubing@yahoogroups.com <=
/DIV>
Sent: Saturday, September 15, 2018=
4:14=20
AM

Subject: Re: [MC4D] Notation and t=
urn=20
metrics for the 2x2x2x2


 =20

This all sounds great to me. Comments in-line.


On 9/13/2018 2:19 PM, Andrew Farkas class=3Dmoz-txt-link-abbreviated=20
href=3D"mailto:ajfarkas12@gmail.com">ajfarkas12@gmail.com [4D_Cubing]=
=20
wrote:

cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">









Hey everyone!



I've been working on the random-state=20
scrambler/solver and discussing things with Marc over the past few days=
, and=20
I've come up with some things that I think are worth sharing.



Notation

I've yet to see a proper compendium of notat=
ion for=20
the 2^4, so here's my proposal for moves in the horizontal=20
orientation:



  • A face R, L, I, or O, followed by one=
    of=20
    the following:


    • Any letter r,=20
      l, u, d, f, b>, x, y, z (plus=20
      an optional ' or 2).=20
IV>

I=20
get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instance =
I get=20
Rz but not Ru.


cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">












    • A pair of square brackets containing any sequence of href=3D"https://www.speedsolving.com/wiki/index.php/Notation"=20
      target=3D_blank moz=3D"true">3D moves that are valid on a 2x2x2=
      .=20

      • Most of the time, of course, these moves should be 0-mod-4.=20

  • The moves U2, D2, F2, and B2.>
  • The full puzzle rotations x, x', x2, y2B>,=20
    and z2.=20
  • The stacking moves M, M', M2, E, and=
    =20
    S.=20

    • M moves the right endcap over to the left of the pu=
      zzle;=20
      M' does the opposite, and M2 swaps the left=
      and=20
      right halves of the puzzle.=20
    • E swaps the top and bottom halves of the puzzle.=20
    • S swaps the front and back halves of the puzzle.=20
<=
/DIV>

Sounds=20
fine though where did the names M, E, and S come fro=
m? I=20
probably just missed it, but I need mnemonics for them. Or maybe somethin=
g a=20
little more self-descriptive might help, like Sd where S me=
ans=20
"Stack" and 'd' is the direction x, y, or z. Or following y=
our=20
'clam' suggestion, they could be x stack, y' stack,=
=20
etc.


cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">











  • z clam and z' clam.=20

    • z clam is a z rotation followed by=
      a=20
      clamshell move.=20
    • z' clam is a z' rotation followed by a=
      =20
      clamshell move.=20
    • z clam and z' clam are inverses.=20
<=
/DIV>

cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">











  • Parentheses can be used for grouping, and numbers can follow=20
    parentheses to repeat a sequence.=20
  • href=3D"https://www.speedsolving.com/wiki/index.php/Commutators_and_C=
    onjugates"=20
    target=3D_blank moz=3D"true">Commutator notation is allowed when =
    useful.=20

The use of lowercase letters in moves like Rr may be=20
controversial; if they are deemed confusing, R[R] coul=
d be=20
encouraged instead.



Here's an equivalent of Melinda's original gyro sequence in this=20
notation:

M E z' clam (x z' clam)2 


DIV>
It's=20
nice that you included the clamshell move but does it belong here since w=
e=20
decided to not call it canonical? Maybe we could use some form of macro=20
notation for naming sequences built from canonical moves and previously=20
defined sequences. For instance perhaps I could define

let clam =3D R2 U2 R2
and then use =
clam=20
and clam' wherever I like. Someone following my sequences woul=
d be=20
free to use the above canonical moves or perform the clamshell move as a=
=20
shortcut since the results are identical. I could then define my gyro as<=
BR>
let gyro =3D M E clam (x clam')2
E>And=20
of course if someone prefers a different gyro move they can just use that=
=20
since again the results are identical. Or is this all just overkill?
<=
BR>
cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">










I'll briefly digress to discuss a href=3D"https://www.worldcubeassociation.org/regulations/#4d1" target=
=3D_blank=20
moz=3D"true">WCA-inspired "standard orientation" that Marc and I ha=
ve been=20
using. WCA regulations state that white face should be on top (Y axis) =
and=20
the green face should be on the front (Z axis). On a standard NxNxN, th=
is=20
will result in the red face on the right (X axis). [...]


DIV>

Makes=20
sense.


cite=3Dmid:CALmdYqrfCi1Wvbc7bcwVXaWnt16-mELSL5ptk+DEGpoWw5kzLw@mail.gmail=
.com=20
type=3D"cite">












Metric

As for counting numbers of moves, I'd like to propose the "snap"=20
metric. Each separation and reattachment of pieces is a single move.. T=
his=20
can be very dependent on how a move is executed, but I think it makes t=
he=20
most sense for the purpose of solving and speedsolving.



A single move like Iy could be executed in three snaps=
as=20
M Ry M' or in just two snaps by rearranging the right and l=
eft=20
endcaps around the I layer.. A sequence like x' Rz Lz'=20
M2 may seem like a lot of moves, but it can be executed in one=
=20
snap. (The x' is actually zero snaps, regardless of context=
.)=20
The sequence z' clam is two snaps, while the equivalent =
Rx2=20
U2 (R[x2 y'] Ly) is three snaps. Ix can be execute=
d as=20
three snaps with M Rx M', two snaps with Rr Ll' x', or on=
e=20
snap by holding the endcaps with one hand and rotating the=20
I layer with the other. (In an actual solve, the two-snap m=
ethod=20
is probably fastest.) While Rr is pretty clearly one snap,=
=20
Ru could be executed in two snaps (by separating the left a=
nd=20
right halves, performing Ru, and then reattaching them) or one s=
nap=20
(by removing the four pieces of Ru directly, rotating them,=
and=20
replacing=20
them).
<=
/DIV>
I=20
like the snap metric a lot for quantifying the amount of work or physical=
=20
complexity of some sequence. I don't know if it makes sense to use for=20
fewest-moves contests for example, but it could be very helpful for compa=
ring=20
and streamlining algorithms.

-Melinda



------=_NextPart_001_0024_01D44CDE.B63ABB20--

------=_NextPart_000_0023_01D44CDE.B63ABB20
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <2E13950B024740CF91C85A667197EF91@LAB>

Content-Type: image/jpeg;
name="2x2x2x2 skizze b.JPG"
Content-Transfer-Encoding: base64
Content-ID: <2E13950B024740CF91C85A667197EF91@LAB>

------=_NextPart_000_0023_01D44CDE.B63ABB20
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID:

Content-Type: image/jpeg;
name="2x2x2x2 skizze c.JPG"
Content-Transfer-Encoding: base64
Content-ID:

------=_NextPart_000_0023_01D44CDE.B63ABB20
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <36134E8ECAFE4219AE033B8700C40667@LAB>

Content-Type: image/jpeg;
name="2x2x2x2 skizze d.JPG"
Content-Transfer-Encoding: base64
Content-ID: <36134E8ECAFE4219AE033B8700C40667@LAB>

------=_NextPart_000_0023_01D44CDE.B63ABB20
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <98A62AA228614106BC6CCF0654448783@LAB>

Content-Type: image/jpeg;
name="2x2x2x2 skizze e.JPG"
Content-Transfer-Encoding: base64
Content-ID: <98A62AA228614106BC6CCF0654448783@LAB>

------=_NextPart_000_0023_01D44CDE.B63ABB20
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <5124389D064245E09DD84DDFD9013FF4@LAB>

Content-Type: image/jpeg;
name="2x2x2x2 skizze f.JPG"
Content-Transfer-Encoding: base64
Content-ID: <5124389D064245E09DD84DDFD9013FF4@LAB>

------=_NextPart_000_0023_01D44CDE.B63ABB20--



From: Andrew Farkas <ajfarkas12@gmail.com>
Date: Sat, 15 Sep 2018 20:12:18 -0400
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2



--0000000000001b69310575f1ebb3
Content-Type: multipart/alternative; boundary="0000000000001b692f0575f1ebb2"

--0000000000001b692f0575f1ebb2
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

I tried to include every move I've heard of, whether or not it is
considered canonical, since they may be useful in scrambling or describing
gyro sequences. *Ru* and similar are equivalent to their bracketed forms;
e.g. *R[U]*. (These are ROIL-style 3D moves) *M*, *E*, and *S* are the
letters used for slice moves
on
(n>2)^3 puzzles, which I noticed Marc had used to describe stacking moves
on the twisty-stacky 2^3.

I entirely agree that the snap metric should not be used for any
fewest-moves competition, since it's rather subjective (as I pointed out);
I only intend for it to be used in the context of quantifying the
difficulty of an algorithm.

Speaking of canonical moves, is there a consensus on those 3D moves (other
than the 0-mod-4 restriction)? Fourtega as it exists right now (which I'd
like to call "Parallel Fourtega," since there may be a 4D Ortega variant in
the future that does not solve the two halves in parallel/separately =F0=9F=
=98=89) is
highly dependent on them, but there could surely be other methods that
solve the puzzle more holistically.

- Andy

On Sat, Sep 15, 2018 at 3:55 PM 'Eduard Baumann' ed.baumann@bluewin.ch
[4D_Cubing] <4D_Cubing@yahoogroups.com> wrote:

>
>
> =EF=BB=BF
> More pictures for the notation for 2x2x2x2
>
>
>
>
>
>
>
>
>
>
> Best regards
> Ed
>
>
> ----- Original Message -----
> *From:* Melinda Green melinda@superliminal.com [4D_Cubing]
>
> *To:* 4D_Cubing@yahoogroups.com
> *Sent:* Saturday, September 15, 2018 4:14 AM
> *Subject:* Re: [MC4D] Notation and turn metrics for the 2x2x2x2
>
>
>
> This all sounds great to me. Comments in-line.
>
> On 9/13/2018 2:19 PM, Andrew Farkas ajfarkas12@gmail.com [4D_Cubing]
> wrote:
>
> Hey everyone!
>
> I've been working on the random-state scrambler/solver and discussing
> things with Marc over the past few days, and I've come up with some thing=
s
> that I think are worth sharing.
>
> Notation
> I've yet to see a proper compendium of notation for the 2^4, so here's my
> proposal for moves in the horizontal orientation:
>
> - A face *R*, *L*, *I*, or *O*, followed by one of the following:
> - Any letter *r*, *l*, *u*, *d*, *f*, *b*, *x*, *y*, *z* (plus an
> optional *'* or *2*).
>
>
> I get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instanc=
e
> I get *Rz *but not *Ru*.
>
>
> - A pair of square brackets containing any sequence of 3D moves
> that are
> valid on a 2x2x2.
> - Most of the time, of course, these moves should be 0-mod-4.
> - The moves *U2*, *D2*, *F2*, and *B2*.
> - The full puzzle rotations *x*, *x'*, *x2*, *y2*, and *z2*.
> - The stacking moves *M*, *M'*, *M2*, *E*, and *S*.
> - *M* moves the right endcap over to the left of the puzzle; *M'* d=
oes
> the opposite, and *M2* swaps the left and right halves of the
> puzzle.
> - *E* swaps the top and bottom halves of the puzzle.
> - *S* swaps the front and back halves of the puzzle.
>
>
> Sounds fine though where did the names *M*, *E*, and *S *come from? I
> probably just missed it, but I need mnemonics for them. Or maybe somethin=
g
> a little more self-descriptive might help, like *Sd *where *S *means
> "Stack" and 'd' is the direction *x, y, *or *z*. Or following your '*clam=
*'
> suggestion, they could be *x stack*, *y' stack*, etc.
>
>
> - *z clam* and *z' clam*.
> - *z clam* is a *z* rotation followed by a clamshell move.
> - *z' clam* is a *z'* rotation followed by a clamshell move.
> - *z clam* and *z' clam* are inverses.
>
>
> - Parentheses can be used for grouping, and numbers can follow
> parentheses to repeat a sequence.
> - Commutator notation
> s>
> is allowed when useful.
>
> The use of lowercase letters in moves like *Rr* may be controversial; if
> they are deemed confusing, *R[R]* could be encouraged instead.
>
> Here's an equivalent of Melinda's original gyro sequence in this notation=
:
> *M E z' clam (x z' clam)2 *
>
>
> It's nice that you included the clamshell move but does it belong here
> since we decided to not call it canonical? Maybe we could use some form o=
f
> macro notation for naming sequences built from canonical moves and
> previously defined sequences. For instance perhaps I could define
>
> *let clam =3D R2 U2 R2*
>
> and then use *clam *and *clam'* wherever I like. Someone following my
> sequences would be free to use the above canonical moves or perform the
> clamshell move as a shortcut since the results are identical. I could the=
n
> define my gyro as
>
> *let gyro =3D M E clam** (x clam')2*
>
> And of course if someone prefers a different gyro move they can just use
> that since again the results are identical. Or is this all just overkill?
>
> I'll briefly digress to discuss a WCA-inspired
> "standard
> orientation" that Marc and I have been using. WCA regulations state that
> white face should be on top (Y axis) and the green face should be on the
> front (Z axis). On a standard NxNxN, this will result in the red face on
> the right (X axis). [...]
>
>
> Makes sense.
>
>
> Metric
> As for counting numbers of moves, I'd like to propose the "snap" metric.
> Each separation and reattachment of pieces is a single move.. This can be
> very dependent on how a move is executed, but I think it makes the most
> sense for the purpose of solving and speedsolving.
>
> A single move like *Iy* could be executed in three snaps as *M Ry M'* or
> in just two snaps by rearranging the right and left endcaps around the *I=
* layer..
> A sequence like *x' Rz Lz' M2* may seem like a lot of moves, but it can
> be executed in one snap. (The *x'* is actually zero snaps, regardless of
> context..) The sequence *z' clam* is two snaps, while the equivalent *Rx2
> U2 (R[x2 y'] Ly)* is three snaps. *Ix* can be executed as three snaps
> with *M Rx M'*, two snaps with *Rr Ll' x'*, or one snap by holding the
> endcaps with one hand and rotating the *I* layer with the other. (In an
> actual solve, the two-snap method is probably fastest.) While *Rr* is
> pretty clearly one snap, *Ru* could be executed in two snaps (by
> separating the left and right halves, performing *Ru*, and then
> reattaching them) or one snap (by removing the four pieces of *Ru* direct=
ly,
> rotating them, and replacing them).
>
>
> I like the snap metric a lot for quantifying the amount of work or
> physical complexity of some sequence. I don't know if it makes sense to u=
se
> for fewest-moves contests for example, but it could be very helpful for
> comparing and streamlining algorithms.
>
> -Melinda
>
>=20
>


--=20

"Machines take me by surprise with great frequency." - Alan Turing

--0000000000001b692f0575f1ebb2
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

t ms,sans-serif">I tried to include every move I've heard of, whether o=
r not it is considered canonical, since they may be useful in scrambling or=
describing gyro sequences. Ru=C2=A0and similar are equivalent to th=
eir bracketed forms; e.g.=C2=A0R[U]. (These are ROIL-style 3D moves)=
M, E, and S=C2=A0are the letters used for https://www.speedsolving.com/wiki/index.php/3x3x3_notation#Slice_Turns">sli=
ce moves=C2=A0on (n>2)^3 puzzles, which I noticed Marc had used to d=
escribe stacking moves on the twisty-stacky 2^3.
efault" style=3D"font-family:trebuchet ms,sans-serif">
=3D"gmail_default" style=3D"font-family:trebuchet ms,sans-serif">I entirely=
agree that the snap metric should not be used for any fewest-moves competi=
tion, since it's rather subjective (as I pointed out); I only intend fo=
r it to be used in the context of quantifying the difficulty of an algorith=
m.
-serif">
et ms,sans-serif">Speaking of canonical moves, is there a consensus on thos=
e 3D moves (other than the 0-mod-4 restriction)? Fourtega as it exists righ=
t now (which I'd like to call "Parallel Fourtega," since ther=
e may be a 4D Ortega variant in the future that does not solve the two halv=
es in parallel/separately =F0=9F=98=89) is highly dependent on them, but th=
ere could surely be other methods that solve the puzzle more holistically.<=
/div>
rif">
ms,sans-serif">- Andy

"ltr">On Sat, Sep 15, 2018 at 3:55 PM 'Eduard Baumann' ailto:ed.baumann@bluewin.ch">ed.baumann@bluewin.ch [4D_Cubing] <ref=3D"mailto:4D_Cubing@yahoogroups.com">4D_Cubing@yahoogroups.com> =
wrote:
x;border-left:1px #ccc solid;padding-left:1ex">












=20

=C2=A0







=20=20=20=20=20=20
=20=20=20=20=20=20

=EF=BB=BF


More pictures for the notation for=20
2x2x2x2

=C2=A0

50B024740CF91C85A667197EF91@LAB">

=C2=A0

=C2=A0

8895457423FBA5386E1A464A75C@LAB">

=C2=A0

=C2=A0

E8ECAFE4219AE033B8700C40667@LAB">

=C2=A0

=C2=A0

AA228614106BC6CCF0654448783@LAB">

=C2=A0

=C2=A0

89D064245E09DD84DDFD9013FF4@LAB">

=C2=A0

Best regards

Ed

=C2=A0

IGHT:0px">
----- Original Message -----



Sent: Saturday, September 15, 2018 =
4:14=20
AM

Subject: Re: [MC4D] Notation and tu=
rn=20
metrics for the 2x2x2x2


=C2=A0=20

This all sounds great to me. Comments in-line.


On 9/13/2018 2:19 PM=
, Andrew Farkas href=3D"mailto:ajfarkas12@gmail.com" target=3D"_blank">ajfarkas12@gmail.co=
m [4D_Cubing]=20
wrote:











Hey everyone!



I've been working on the random-state=
=20
scrambler/solver and discussing things with Marc over the past few days=
, and=20
I've come up with some things that I think are worth sharing.



Notation

I've yet to see a proper compendium of=
notation for=20
the 2^4, so here's my proposal for moves in the horizontal=20
orientation:



  • A face R, L, I, or O, followed by one=
    of=20
    the following:


    • Any letter=C2=A0r,=20
      l,=C2=A0u,=C2=A0d,=C2=A0f,=C2=A0b>,=C2=A0x,=C2=A0y,=C2=A0z=C2=A0(plus=20
      an optional '=C2=A0or 2).=20
iv>

I=20
get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For instance =
I get=20
Rz but not Ru.















  • The moves U2, D2, F2, and=C2=A0B2.>
  • The full puzzle rotations x, x', x2, =
    y2    ,=20
    and z2.=20
  • The stacking moves M, M', M2, E, =
    and=20
    S.=20

    • M=C2=A0moves the right endcap over to the left of the pu=
      zzle;=20
      M'=C2=A0does the opposite, and M2=C2=A0swaps the =
      left and=20
      right halves of the puzzle.=20
    • E=C2=A0swaps the top and bottom halves of the puzzle.=20
    • S=C2=A0swaps the front and back halves of the puzzle.=20
>

Sounds=20
fine though where did the names M, E, and S come fro=
m? I=20
probably just missed it, but I need mnemonics for them. Or maybe somethin=
g a=20
little more self-descriptive might help, like Sd where S me=
ans=20
"Stack" and 'd' is the direction x, y, or zb>. Or following your=20
'clam' suggestion, they could be x stack, y'=
stack,=20
etc.














  • z clam and z' clam.=20

    • z clam=C2=A0is a=C2=A0z=C2=A0rotation followed by=
      a=20
      clamshell move.=20
    • z' clam=C2=A0is a z'=C2=A0rotation follow=
      ed by a=20
      clamshell move.=20
    • z clam=C2=A0and z' clam=C2=A0are inverses.=20
iv>













The use of lowercase letters in moves like Rr=C2=A0may be=20
controversial; if they are deemed confusing,=C2=A0R[R]=C2=A0coul=
d be=20
encouraged instead.



Here's an equivalent of Melinda's original gyro sequence i=
n this=20
notation:

M E z' clam (x z' clam)2=C2=A0


div>

It's=20
nice that you included the clamshell move but does it belong here since w=
e=20
decided to not call it canonical? Maybe we could use some form of macro=20
notation for naming sequences built from canonical moves and previously=20
defined sequences. For instance perhaps I could define

let clam =3D R2 U2 R2
and then use =
clam=20
and clam' wherever I like. Someone following my sequences =
would be=20
free to use the above canonical moves or perform the clamshell move as a=
=20
shortcut since the results are identical. I could then define my gyro as<=
br>
let gyro =3D M E clam (x clam')2
quote>And=20
of course if someone prefers a different gyro move they can just use that=
=20
since again the results are identical. Or is this all just overkill?
<=
br>











I'll briefly digress to discuss a cubeassociation.org/regulations/#4d1" target=3D"_blank">WCA-inspired &q=
uot;standard orientation" that Marc and I have been=20
using. WCA regulations state that white face should be on top (Y axis) =
and=20
the green face should be on the front (Z axis). On a standard NxNxN, th=
is=20
will result in the red face on the right (X axis). [...]


div>

Makes=20
sense.















Metric

As for counting numbers of moves, I'd like to propose the &quo=
t;snap"=20
metric. Each separation and reattachment of pieces is a single move.. T=
his=20
can be very dependent on how a move is executed, but I think it makes t=
he=20
most sense for the purpose of solving and speedsolving.



A single move like Iy=C2=A0could be executed in three snaps=
as=20
M Ry M'=C2=A0or in just two snaps by rearranging the right a=
nd left=20
endcaps around the I=C2=A0layer.. A sequence like x' Rz L=
z'=20
M2=C2=A0may seem like a lot of moves, but it can be executed in one=
=20
snap. (The x'=C2=A0is actually zero snaps, regardless of con=
text..)=20
The sequence z' clam=C2=A0is two snaps, while the equivalent=
Rx2=20
U2 (R[x2 y'] Ly)=C2=A0is three snaps. Ix=C2=A0can be exe=
cuted as=20
three snaps with M Rx M', two snaps with Rr Ll' x'=
;, or one=20
snap by holding the endcaps with one hand and rotating the=20
I=C2=A0layer with the other. (In an actual solve, the two-snap m=
ethod=20
is probably fastest.) While Rr=C2=A0is pretty clearly one snap,=
=20
Ru=C2=A0could be executed in two snaps (by separating the left a=
nd=20
right halves, performing Ru, and then reattaching them) or one s=
nap=20
(by removing the four pieces of Ru=C2=A0directly, rotating them,=
and=20
replacing=20
them).
<=
/div>

I=20
like the snap metric a lot for quantifying the amount of work or physical=
=20
complexity of some sequence. I don't know if it makes sense to use fo=
r=20
fewest-moves contests for example, but it could be very helpful for compa=
ring=20
and streamlining algorithms.

-Melinda





=20=20=20=20=20

=20=20=20=20







=20=20








--
class=3D"gmail_signature" data-smartmail=3D"gmail_signature">
tr">
r>
"1">"Machines take me by surprise with great frequency." - Alan T=
uring


--0000000000001b692f0575f1ebb2--

--0000000000001b69310575f1ebb3
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <165df8d71331bfc6c491>
X-Attachment-Id: 165df8d71331bfc6c491

Content-Type: image/jpeg; name="2x2x2x2 skizze b.JPG"
Content-Disposition: inline; filename="2x2x2x2 skizze b.JPG"
Content-Transfer-Encoding: base64
Content-ID: <165df8d71331bfc6c491>
X-Attachment-Id: 165df8d71331bfc6c491

--0000000000001b69310575f1ebb3
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <165df8d71341c0a83ca2>
X-Attachment-Id: 165df8d71341c0a83ca2

Content-Type: image/jpeg; name="2x2x2x2 skizze c.JPG"
Content-Disposition: inline; filename="2x2x2x2 skizze c.JPG"
Content-Transfer-Encoding: base64
Content-ID: <165df8d71341c0a83ca2>
X-Attachment-Id: 165df8d71341c0a83ca2

--0000000000001b69310575f1ebb3
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <165df8d71341c189b4b3>
X-Attachment-Id: 165df8d71341c189b4b3

Content-Type: image/jpeg; name="2x2x2x2 skizze d.JPG"
Content-Disposition: inline; filename="2x2x2x2 skizze d.JPG"
Content-Transfer-Encoding: base64
Content-ID: <165df8d71341c189b4b3>
X-Attachment-Id: 165df8d71341c189b4b3

--0000000000001b69310575f1ebb3
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <165df8d71341c26b2cc4>
X-Attachment-Id: 165df8d71341c26b2cc4

Content-Type: image/jpeg; name="2x2x2x2 skizze e.JPG"
Content-Disposition: inline; filename="2x2x2x2 skizze e.JPG"
Content-Transfer-Encoding: base64
Content-ID: <165df8d71341c26b2cc4>
X-Attachment-Id: 165df8d71341c26b2cc4

--0000000000001b69310575f1ebb3
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <165df8d71341c34ca4d5>
X-Attachment-Id: 165df8d71341c34ca4d5

Content-Type: image/jpeg; name="2x2x2x2 skizze f.JPG"
Content-Disposition: inline; filename="2x2x2x2 skizze f.JPG"
Content-Transfer-Encoding: base64
Content-ID: <165df8d71341c34ca4d5>
X-Attachment-Id: 165df8d71341c34ca4d5

--0000000000001b69310575f1ebb3
Content-Type: application/x-ygp-stripped
Content-Transfer-Encoding: 7bit
Content-ID: <>
X-Attachment-Id:

Content-Type: image/jpeg; name="2x2x2x2 skizze c.JPG"
Content-Disposition: inline; filename="2x2x2x2 skizze c.JPG"
Content-Transfer-Encoding: base64
Content-ID: <>
X-Attachment-Id:

--0000000000001b69310575f1ebb3--



From: Melinda Green <melinda@superliminal.com>
Date: Sat, 15 Sep 2018 17:29:17 -0700
Subject: Re: [MC4D] Notation and turn metrics for the 2x2x2x2



--------------B9F2A3AB4AF4C71BA63183CC
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable

Regarding 0 mod 4, I would only say that any sequence of 2^3 twists on one =
half of the puzzle should be accounted for on the other half. That can be d=
one with every twist using the axial move, or by keeping track of the mod 4=
count and applying the reverse of any remainder at the end of the sequence=
. 0 mod 4 sequences are therefore nice because you don't need to keep track=
, but other sequences are fine too, just more work.

-Melinda

On 9/15/2018 5:12 PM, Andrew Farkas ajfarkas12@gmail.com [4D_Cubing] wrote:
>
>
> I tried to include every move I've heard of, whether or not it is conside=
red canonical, since they may be useful in scrambling or describing gyro se=
quences. *Ru*=C2=A0and similar are equivalent to their bracketed forms; e.g=
. *R[U]*. (These are ROIL-style 3D moves) *M*, *E*, and *S*=C2=A0are the le=
tters used for slice moves x3_notation#Slice_Turns>=C2=A0on (n>2)^3 puzzles, which I noticed Marc had =
used to describe stacking moves on the twisty-stacky 2^3.
>
> I entirely agree that the snap metric should not be used for any fewest-m=
oves competition, since it's rather subjective (as I pointed out); I only i=
ntend for it to be used in the context of quantifying the difficulty of an =
algorithm.
>
> Speaking of canonical moves, is there a consensus on those 3D moves (othe=
r than the 0-mod-4 restriction)? Fourtega as it exists right now (which I'd=
like to call "Parallel Fourtega," since there may be a 4D Ortega variant i=
n the future that does not solve the two halves in parallel/separately =F0=
=9F=98=89) is highly dependent on them, but there could surely be other met=
hods that solve the puzzle more holistically.
>
> - Andy
>
> On Sat, Sep 15, 2018 at 3:55 PM 'Eduard Baumann' ed.baumann@bluewin.ch ailto:ed.baumann@bluewin.ch> [4D_Cubing] <4D_Cubing@yahoogroups.com :4D_Cubing@yahoogroups.com>> wrote:
>
> =EF=BB=BF
>
> More pictures for the notation for 2x2x2x2
> Best regards
> Ed
>
> ----- Original Message -----
> *From:* Melinda Green melinda@superliminal.com [4D_Cubing] o:melinda@superliminal.com+[4D_Cubing]>
> *To:* 4D_Cubing@yahoogroups.com >
> *Sent:* Saturday, September 15, 2018 4:14 AM
> *Subject:* Re: [MC4D] Notation and turn metrics for the 2x2x2x2
>
> This all sounds great to me. Comments in-line.
>
> On 9/13/2018 2:19 PM, Andrew Farkas ajfarkas12@gmail.com ajfarkas12@gmail.com> [4D_Cubing] wrote:
>> Hey everyone!
>>
>> I've been working on the random-state scrambler/solver and discu=
ssing things with Marc over the past few days, and I've come up with some t=
hings that I think are worth sharing.
>>
>> Notation
>> I've yet to see a proper compendium of notation for the 2^4, so =
here's my proposal for moves in the horizontal orientation:
>>
>> * A face *R*, *L*, *I*, or *O*, followed by one of the followi=
ng:
>> o Any letter *r*, *l*, *u*, *d*, *f*, *b*, *x*, *y*, *z*=
=C2=A0(plus an optional *'*=C2=A0or *2*).
>>
>
> I get the x,y,z moves but what do the r,l,u,d,f,b moves mean? For=
instance I get *Rz *but not *Ru*.
>
>> o A pair of square brackets containing any sequence of 3D =
moves that are valid=
on a 2x2x2.
>> + Most of the time, of course, these moves should be 0=
-mod-4.
>> * The moves *U2*, *D2*, *F2*, and *B2*.
>> * The full puzzle rotations *x*, *x'*, *x2*, *y2*, and *z2*.
>> * The stacking moves *M*, *M'*, *M2*, *E*, and *S*.
>> o *M*=C2=A0moves the right endcap over to the left of the =
puzzle; *M'*=C2=A0does the opposite, and *M2*=C2=A0swaps the left and right=
halves of the puzzle.
>> o *E*=C2=A0swaps the top and bottom halves of the puzzle.
>> o *S*=C2=A0swaps the front and back halves of the puzzle.
>>
>
> Sounds fine though where did the names *M*, *E*, and *S *come fro=
m? I probably just missed it, but I need mnemonics for them. Or maybe somet=
hing a little more self-descriptive might help, like *Sd *where *S *means "=
Stack" and 'd' is the direction *x, y, *or *z*. Or following your '*clam*' =
suggestion, they could be *x stack*, *y' stack*, etc.
>
>> * *z clam* and *z' clam*.
>> o *z clam*=C2=A0is a *z*=C2=A0rotation followed by a clams=
hell move.
>> o *z' clam*=C2=A0is a *z'*=C2=A0rotation followed by a cla=
mshell move.
>> o *z clam*=C2=A0and *z' clam*=C2=A0are inverses.
>>
>> * Parentheses can be used for grouping, and numbers can follow=
parentheses to repeat a sequence.
>> * Commutator notation .php/Commutators_and_Conjugates> is allowed when useful.
>>
>> The use of lowercase letters in moves like *Rr*=C2=A0may be cont=
roversial; if they are deemed confusing, *R[R]*=C2=A0could be encouraged in=
stead.
>>
>> Here's an equivalent of Melinda's original gyro sequence in this=
notation:
>> *M E z' clam (x z' clam)2 *
>>
>
> It's nice that you included the clamshell move but does it belong=
here since we decided to not call it canonical? Maybe we could use some fo=
rm of macro notation for naming sequences built from canonical moves and pr=
eviously defined sequences. For instance perhaps I could define
>
> *let clam =3D R2 U2 R2*
>
> and then use *clam *and *clam'* wherever I like. Someone followin=
g my sequences would be free to use the above canonical moves or perform th=
e clamshell move as a shortcut since the results are identical. I could the=
n define my gyro as
>
> *let gyro =3D M E clam**(x clam')2*
>
> And of course if someone prefers a different gyro move they can j=
ust use that since again the results are identical. Or is this all just ove=
rkill?
>
>> I'll briefly digress to discuss a WCA-inspired dcubeassociation.org/regulations/#4d1> "standard orientation" that Marc and=
I have been using. WCA regulations state that white face should be on top =
(Y axis) and the green face should be on the front (Z axis). On a standard =
NxNxN, this will result in the red face on the right (X axis). [...]
>>
>
> Makes sense.
>
>>
>> Metric
>> As for counting numbers of moves, I'd like to propose the "snap"=
metric. Each separation and reattachment of pieces is a single move.. This=
can be very dependent on how a move is executed, but I think it makes the =
most sense for the purpose of solving and speedsolving.
>>
>> A single move like *Iy*=C2=A0could be executed in three snaps as=
*M Ry M'*=C2=A0or in just two snaps by rearranging the right and left endc=
aps around the *I*=C2=A0layer.. A sequence like *x' Rz Lz' M2*=C2=A0may see=
m like a lot of moves, but it can be executed in one snap. (The *x'*=C2=A0i=
s actually zero snaps, regardless of context..) The sequence *z' clam*=C2=
=A0is two snaps, while the equivalent *Rx2 U2 (R[x2 y'] Ly)*=C2=A0is three =
snaps. *Ix*=C2=A0can be executed as three snaps with *M Rx M'*, two snaps w=
ith *Rr Ll' x'*, or one snap by holding the endcaps with one hand and rotat=
ing the *I*=C2=A0layer with the other. (In an actual solve, the two-snap me=
thod is probably fastest.) While *Rr*=C2=A0is pretty clearly one snap, *Ru*=
=C2=A0could be executed in two snaps (by separating the left and right halv=
es, performing *Ru*, and then reattaching them) or one snap (by removing th=
e four pieces of *Ru*=C2=A0directly, rotating them, and replacing them).
>
> I like the snap metric a lot for quantifying the amount of work o=
r physical complexity of some sequence. I don't know if it makes sense to u=
se for fewest-moves contests for example, but it could be very helpful for =
comparing and streamlining algorithms.
>
> -Melinda
>


--------------B9F2A3AB4AF4C71BA63183CC
Content-Type: text/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable



">


Regarding 0 mod 4, I would only say that any sequence of 2^3 twists
on one half of the puzzle should be accounted for on the other half.
That can be done with every twist using the axial move, or by
keeping track of the mod 4 count and applying the reverse of any
remainder at the end of the sequence. 0 mod 4 sequences are
therefore nice because you don't need to keep track, but other
sequences are fine too, just more work.



-Melinda



On 9/15/2018 5:12 PM, Andrew Farkas
.com">ajfarkas12@gmail.com [4D_Cubing] wrote:


cite=3D"mid:CALmdYqq0dfm5qGJEcUPRcbApsKPUpj5kGD4Gf+WdJ+6AUfc8tQ@mail.gmail.=
com">
-8">



ms,sans-serif">I tried to include every move I've heard of,
whether or not it is considered canonical, since they may be
useful in scrambling or describing gyro sequences. Ru=C2=
=A0and
similar are equivalent to their bracketed forms; e.g.=C2=A0R[U=
].
(These are ROIL-style 3D moves) M, E, and S=
=C2=A0are
the letters used for href=3D"https://www.speedsolving.com/wiki/index.php/3x3x3_notation#Slice_Tu=
rns"
moz-do-not-send=3D"true">slice moves=C2=A0on (n>2)^3
puzzles, which I noticed Marc had used to describe stacking
moves on the twisty-stacky 2^3.

ms,sans-serif">


ms,sans-serif">I entirely agree that the snap metric should
not be used for any fewest-moves competition, since it's
rather subjective (as I pointed out); I only intend for it to
be used in the context of quantifying the difficulty of an
algorithm.

ms,sans-serif">


ms,sans-serif">Speaking of canonical moves, is there a
consensus on those 3D moves (other than the 0-mod-4
restriction)? Fourtega as it exists right now (which I'd like
to call "Parallel Fourtega," since there may be a 4D Ortega
variant in the future that does not solve the two halves in
parallel/separately =F0=9F=98=89) is highly dependent on them, bu=
t there
could surely be other methods that solve the puzzle more
holistically.

ms,sans-serif">


ms,sans-serif">- Andy





On Sat, Sep 15, 2018 at 3:55 PM 'Eduard Baumann'
>ed.baumann@bluewin.ch
[4D_Cubing] < moz-do-not-send=3D"true">4D_Cubing@yahoogroups.com>
wrote:


.8ex;border-left:1px #ccc solid;padding-left:1ex">

=C2=A0



=EF=BB=BF


More pictures for th=
e
notation for 2x2x2x2

=C2=A0

3D""<br/ src=3D"cid:2E13950B024740CF91C85A667197EF91@LAB"
moz-do-not-send=3D"true" align=3D"bottom" hspace=3D"0=
"
border=3D"0">

=C2=A0

=C2=A0

3D""<br/ src=3D"cid:C5FF98895457423FBA5386E1A464A75C@LAB"
moz-do-not-send=3D"true" align=3D"bottom" hspace=3D"0=
"
border=3D"0">

=C2=A0

=C2=A0

3D""<br/ src=3D"cid:36134E8ECAFE4219AE033B8700C40667@LAB"
moz-do-not-send=3D"true" align=3D"bottom" hspace=3D"0=
"
border=3D"0">

=C2=A0

=C2=A0

3D""<br/ src=3D"cid:98A62AA228614106BC6CCF0654448783@LAB"
moz-do-not-send=3D"true" align=3D"bottom" hspace=3D"0=
"
border=3D"0">

=C2=A0

=C2=A0

3D""<br/ src=3D"cid:5124389D064245E09DD84DDFD9013FF4@LAB"
moz-do-not-send=3D"true" align=3D"bottom" hspace=3D"0=
"
border=3D"0">

=C2=A0

Best regards<=
/div>
Ed

=C2=A0

solid;MARGIN-LEFT:5px;MARGIN-RIGHT:0px">
----- Original Message
-----

Fr=
om:
href=3D"mailto:melinda@superliminal.com+[4D_Cubing]=
"
target=3D"_blank" moz-do-not-send=3D"true">Melinda
Green melinda@superliminal.com [4D_Cubing] v>
To: title=3D"4D_Cubing@yahoogroups.com"
href=3D"mailto:4D_Cubing@yahoogroups.com"
target=3D"_blank" moz-do-not-send=3D"true">4D_Cubin=
g@yahoogroups.com

Sent: Saturday,
September 15, 2018 4:14 AM

Subject: Re:
[MC4D] Notation and turn metrics for the 2x2x2x2>



=C2=A0

This all sounds great to me. Comments in-line.




=
On
9/13/2018 2:19 PM, Andrew Farkas class=3D"m_-1038871484344678509moz-txt-link-abbre=
viated"
href=3D"mailto:ajfarkas12@gmail.com"
target=3D"_blank" moz-do-not-send=3D"true">ajfark=
as12@gmail.com
[4D_Cubing] wrote:












Hey
everyone!




I've
been working on the
random-state
scrambler/solver and
discussing things with Marc
over the past few days, and
I've come up with some
things that I think are
worth sharing.




t
size=3D"4">Notationiv>
I've
yet to see a proper
compendium of notation for
the 2^4, so here's my
proposal for moves in the
horizontal orientation:



  • A face R, L=
    ,
    I, or O,
    followed by one of the
    following:


    • Any letter=C2=A0r<=
      /b>,
      l,=C2=A0u=
      ,=C2=A0d,=C2=A0f,=C2=A0b,=C2=A0x,=C2=A0y=
      ,=C2=A0z=C2=A0(plus
      an optional '=C2=
      =A0or
      2).

















I get the x,y,z moves but what do the r,l,u,d,f,b
moves mean? For instance I get Rz but not
Ru.
















    • A pair of square
      brackets containing
      any sequence of href=3D"https://www.spe=
      edsolving.com/wiki/index.php/Notation"
      target=3D"_blank"
      moz-do-not-send=3D"true=
      ">3D
      moves that are
      valid on a 2x2x2.

      • Most of the
        time, of course,
        these moves should
        be 0-mod-4.




  • The moves U2,
    D2, F2,
    and=C2=A0B2.


  • The full puzzle
    rotations x, x'b>,
    x2, y2,
    and z2.

  • The stacking moves Mb>,
    M', M2, E<=
    /b>,
    and S.

    • M=C2=A0moves t=
      he
      right endcap over to
      the left of the
      puzzle; M'=C2=A0=
      does
      the opposite, and M2=
      =C2=A0swaps
      the left and right
      halves of the
      puzzle.

    • E=C2=A0swaps t=
      he
      top and bottom
      halves of the
      puzzle.

    • S=C2=A0swaps t=
      he
      front and back
      halves of the
      puzzle.

















Sounds fine though where did the names M,
E, and S come from? I probably
just missed it, but I need mnemonics for them. Or
maybe something a little more self-descriptive
might help, like Sd where S means
"Stack" and 'd' is the direction x, y, or
z. Or following your 'clam'
suggestion, they could be x stack, y'
stack, etc.















  • z clam and z'
    clam    .

    • z clam=C2=A0is
      a=C2=A0z=C2=A0ro=
      tation
      followed by a
      clamshell move.

    • z' clam=C2=A0i=
      s
      a z'=C2=A0rotati=
      on
      followed by a
      clamshell move.

    • z clam=C2=A0an=
      d
      z' clam=C2=A0are
      inverses.



























  • Parentheses can be
    used for grouping, and
    numbers can follow
    parentheses to repeat a
    sequence.

  • href=3D"https://www.speedsolving.com/wiki/index.php/Commutators_and_Conjuga=
    tes"
    target=3D"_blank"
    moz-do-not-send=3D"true">=
    Commutator
    notation is
    allowed when useful.


The use of lowercase
letters in moves like Rrb>=C2=A0may
be controversial; if they
are deemed confusing,=C2=A0>R[R]=C2=A0could
be encouraged instead.




Here's an equivalent of
Melinda's original gyro
sequence in this notation:iv>
M E z' clam (x z'
clam)2=C2=A0

















It's nice that you included the clamshell move but
does it belong here since we decided to not call
it canonical? Maybe we could use some form of
macro notation for naming sequences built from
canonical moves and previously defined sequences.
For instance perhaps I could define

let clam =3D R2 U2 R2


and then use clam and clam'
wherever I like. Someone following my sequences
would be free to use the above canonical moves or
perform the clamshell move as a shortcut since the
results are identical. I could then define my gyro
as

let gyro =3D M E clam (x
clam')2


And of course if someone prefers a different gyro
move they can just use that since again the
results are identical. Or is this all just
overkill?














I'll briefly digress to
discuss a href=3D"https://www.worldcu=
beassociation.org/regulations/#4d1"
target=3D"_blank"
moz-do-not-send=3D"true">WC=
A-inspired
"standard orientation"
that Marc and I have been
using. WCA regulations
state that white face
should be on top (Y axis)
and the green face should
be on the front (Z axis).
On a standard NxNxN, this
will result in the red
face on the right (X
axis). [...]

















Makes sense.

















Metricont>

As for counting numbers
of moves, I'd like to
propose the "snap" metric.
Each separation and
reattachment of pieces is
a single move.. This can
be very dependent on how a
move is executed, but I
think it makes the most
sense for the purpose of
solving and speedsolving.v>



A single move like Iyb>=C2=A0could
be executed in three snaps
as M Ry M'=C2=A0or in
just two snaps by
rearranging the right and
left endcaps around the I<=
/b>=C2=A0layer..
A sequence like x' Rz
Lz' M2=C2=A0may seem li=
ke
a lot of moves, but it can
be executed in one snap.
(The x'=C2=A0is
actually zero snaps,
regardless of context..)
The sequence z' clam=
=C2=A0is
two snaps, while the
equivalent Rx2 U2
(R[x2 y'] Ly)=C2=A0is
three snaps. Ix=C2=A0c=
an
be executed as three snaps
with M Rx M', two
snaps with Rr Ll' x',
or one snap by holding the
endcaps with one hand and
rotating the I=C2=A0la=
yer
with the other. (In an
actual solve, the two-snap
method is probably
fastest.) While Rr=C2=
=A0is
pretty clearly one snap, R=
u=C2=A0could
be executed in two snaps
(by separating the left
and right halves,
performing Ru, and
then reattaching them) or
one snap (by removing the
four pieces of Ru=C2=
=A0directly,
rotating them, and
replacing them).















I like the snap metric a lot for quantifying the
amount of work or physical complexity of some
sequence. I don't know if it makes sense to use
for fewest-moves contests for example, but it
could be very helpful for comparing and
streamlining algorithms.



-Melinda















--------------B9F2A3AB4AF4C71BA63183CC--