You are on page 1of 8

Notation is based on the description of three things.

The finger being used.

The piece of the puzzle being used.

The grip of the fingers on the cube.


Anywhere that these things are not described in the algorithm, it is left to the solver to figure out (or assume)
what to do (or what can be done) on his/her own. This method is only meant to highlight the parts of algorithms
where one uses a unique or not so obvious finger trick to perform the moves.
The finger notation
Upper case is used to describe the right hand, and lower case is used to describe the left hand.

I - Index

T - Thumb

M - Middle

R - Ring

P - Pinkie

W - Wrist move (generally not needed)


For example (M) means that the right middle finger is in use, while (i) means the left index finger is in use.
The piece notation
As described by DeeDubb, each corner of the side being turned is labelled with the numbers 1-4 in a clockwise
fashion. The front face starting with the corner UFL, the U face beginning with UBL, the D face with DFL, R
with UFR, L with UBL, and B with UBR.
Ergo: On U: 1 = UBL, 2 = UBR, 3 = UFR, 4 = UFL
On F: 1 = UFL, 2 = UFR, 3 = DFR, 4 = DFL
On slice moves, the numbers correspond with the edges "behind" the corners of the side with which it turns.
For example M turns with the L side, and so it's edges will have the same numbers as the corresponding
corners on the L face. S with the F face. E with the D face.
Together, the finger and piece notation form the basic finger trick notation. It is written 'move(fingerPiece)'.

Example: U(I2) means that the right index finger performed the move U by sliding the UBR cubie to
UFR.
Two-turn moves such as F2 are described using two fingers and two pieces, and can use prime to indicate
direction like so: F2'(T3,i1)
The grip notation
Fingers will be labelled the same (upper-case = right, lower = left). All grip notations are written in curly
brackets {...} and only when necessary to define a non-standard or non-intuitive grip.
For basic grips:

TF - Right thumb on front, rest [of fingers] on back.

TU - Right thumb on up, rest [of fingers] on down.

TD - Right thumb on down, rest [of fingers] on up.

TB - Right thumb on back, rest [of fingers] on front (How the wrist is twisted depends on the direction of
the following move)

TR, TL - You get the idea...


For basic groups with left hand: tF, tU, tD, tB, tR, tL (same as right hand)
Piece specific grips are separated by a dash (-). For consistency, corners use DeeDubb's number method for
defining corners. The finger will grip on the side of the corner defined (e.g.: T-R1 means that the right thumb is
either on the top or front face of the 1 corner of the R side, depending on the rest of the grip and on moves).
Edges are defined by the face letters (ex: M-BR, t-FL, t-FD, etc...).
Center pieces are defined simply by the face letter (T-F is different than TF. TF is a basic grip, meaning it
doesn't matter which piece is held. But T-F means the right thumb must be on the center piece).
The grip defined on specific pieces is maintained until a regrip is defined, or a move/trick requires that it be
broken. (ex: {M-UR} R U(M2). This means that the defined grip is broken to perform U.)

Where grip is not defined, a normal grip is assumed (As the cuber feels works for the algorithm)
R U R' U' and L' U' L U = Sexy Move (Red)
R U R' F' and L' U' L F = Sexy Flick (Green)
R' F R F' and L F' L' F = Sledge hammer (Blue)
R U R' U and L' U' L U' = Sune trigger (Yellow)
(Right) Sledgehammer: R'FRF'
(Right) Hedgeslammer: FR'F'R
(Left) Sledgehammer: LF'L'F
(Left) Hedgeslammer: F'LFL'
Mano izquierda casi siempre en q y . Inclinar manos mas de 45
No pegar tant la mano, solo girar con la punta de los dedos, abrir mano
Al girar I tratar de tocar pulgar
Basic Rubik's Cube grips can be defined by the location of each thumb on the cube. We will use an ordered
pair of integers to describe this, where 0 translates to a thumb on the D face. This usually means the DL
or DR face, but really your thumb can float a bit. 1 means a thumb on F, 2 means a thumb on U. A thumb
on the B face can be represented by either -1 or 3, depending on which grip you're coming from. And so
on, and so forth. The two most common grips are (1,0), which means the left thumb is on F, and the right
thumb is on D, and (1,1), where both thumbs are on the F face. After that, grips that I commonly use are
(1,2), which is really just a mirrored verson of (1,0), and (1,-1), which I think of as square-1 grip (along
with (1,1)).
Generally your wrists have a range of motion to permit 5 total unique grips, from a -2 grip like (1,-1), to a
+2 grip, like (1,3). You can extend further than this in theory, but it puts strain on the wrists (and I've
never used an alg that required me to do so). Of course there are also unique grips that aren't as easy to
classify with this system, but these are generally specific to individual algorithms. Performing R and L
moves changes your grip, as do grip changes (where you pick up your thumb and move it to a different
face).
Once you figure out where the thumb is, it's very easy to see which moves can be easily performed with
each hand. With your right hand in a 1 position, you can perform U and D' pull moves. With your left hand
in 1, it's U' and D. With your right hand at 0, it's F and B', at -1 (or 3) it's D and U', and I think you can
figure it out from there. You can also perform "push" moves in the opposite direction (for example, U' and
D with your right hand in the 1 position) You can always perform R and L moves with your wrists, as well
as M and M', with either hand, in any grip. Wide turns follow these as well, though they generally require
you to shift your thumb a bit. I suppose you could also add E and S, which go along with U and F. There
are also moves that can be performed with the thumb (the inverse of the move that can be performed
with the index finger in each grip). These wind up with the thumb on the L/R face, which will require a
regrip to get back to a standard grip.
In a (1,0) grip, you can perform: Pulls: U' U2' F F2 D D2 B' B2'
Pushes: U U2 F' F2' D' D2' B B2
Other: R R' R2 L L' L2 M M' M2 M2'
In a (1,1) grip: Pulls/Pushes: U U' U2 U2' D D' D2 D2'
Others: R R' R2 L L' L2 M M' M2 M2'
In a (1,2) grip: Pulls: U' U2' B B2 D D2 F' F2'
Pushes: U U2 B' B2' D' D2' F F2
Others: R R' R2 L L' L2 M M' M2 M2'

In a (1,-1) or (1,3) grip: Pulls: U' U2' D D2


Pushes: U U2 D' D2'
Others: R R' R2 L L' L2 M M' M2 M2'

{f:f} for your (1,1)


{f:d} for your (1,0)
{f:u} for your (1,2)
{f:b} for your (1,-1)
{f:b'} for your (1,3)

D= mano der horizontal modo hamburguesa meique soportando cubo en esquina y arista
P= mano der vertical moto arrage tubo
b=mano der horizontal volteada modo fap/levantar
C=mano izq horizontal modo hamburguesa meique soportando cubo en esquina
q=mano izq moto arrage tubo
d= mano izq horizontal volteada modo fap/levantar
B
V=mano izq vertical suelo agarrar desde Do q>Z se rotara en Y- Y
W= mano der vertical suelo agarrar desde Do P>Z se rotara en Y- Y
A= mano izq vertical techo agarrar desde U q>Z se rotara en Y- Y
M= mano der vertical techo agarrar desde U P>Z se rotara en Y- Y
=mover mano sin llevar layer. cambiar Romper posicin
C/D= agarrar cara B sin pulgar I sobre U m y r sobre B y en d , i entre dos layers
=agarra centro
= agarrar cara lateral
+= agarrar cara lateral con pulgar en esquina superiorde la cara
-= agarrar cara lateral con pulgar en esquina inferior
= agarrar cara lateral con pulgar en las laterales, indice arriba en BU y medio r en B (M) central bajo.
Otra mano ndice en B media para no bloquear U
ps:: enpujar cara lateral con indice
i@= girar siguiente letra con mismo dedo ndice
t@= girar siguiente letra con mismo dedo pulgar
*m medio mantenerlo en posicion , correrlo/arrastrarlo
*(t)p pulgar mantenerlo en posicion , correrlo/arrastrarlo
U () opcin i>u i@>u/ U i@ empuja atrs der. Izq y romper poco posicion / con m * tocar con la punta
de i el pulgar
U q/P psh:: inverso:tocar pulgar con i y con ua empujar cara U hacia atras u otras caras con I
U () q D ps:: i * arrastara dedos
U() qP i@ con mismo indice
R()2 q/D b se puede girar con los dedos m r t terminar de girar con el dedo m / girar mueca
R opcin C empujar con r(anular) como M
L()2 C d
L opcin L D empujar con r(anular) como M

U2 P i / i m / m i
U2 q i / i m / m i
R si esta en b P empujar con pulgar
F q/ D i C pulgar / P D pulgar para abajo = para F
F C pulgar para abajo = para F
q / D pulgar C i /P
S
E
Secuencias
U U opcin para R q i/ D psh:: i
RU R
q / b p
RU U R
q / b i@ p
RU R
RUU R

q/ D t@ p
q/ + D t@ p I

= pichicato

R U R' /
D > P * no despegar dedos
L' U' L
C > q ** usar i para jalar/empujar U
R U' R' /
P > b *no despegar R. T si
L' U L
// q>d
empezar por U
U B q ps::/ b psh::
U B B U q ps::/ b psh::
URUR q i / P D psh::
R U B B U R q i i@ psh:: / P b psh:: i@
Sexy move(s) :
R U R' U' / D>P
L' U' L U
R' U' R U / P>b
L U L' U'
R U R U b P
R U R U P D
R U R U P b *(t)
U R U' R'
U' L' U L
R U2 R b P
Sledgehammer :
R' F R F' X C / P D *(t)
L F' L' F
RFR q / P D
Edge insertion :
R F R U C / P D
RF R U X X q / P D i@ mover mano izq( Lw U Lw U) mantener mano der
L F L U
R' F' R U R U' R' F /
F' R U R' U' R' F R
D moves :
R' D' R D /

L D L' D'
M slice :
M/M2 q- / P- r / ambas manos bajar aprox 30 empujar desde B hacia abajo m /mano izq mano der
Q/ P m / mr
M/M2 q- / P- r / ambas manos bajar aprox 30 empujar desde D hacia arriba m /mano izq mano der
M U
M U
M' U2
M' U M M' U' M
E / E q- / P- r
B C/D r
B
Ejercicios rapidez
(RU) (U R) q/D C
(R UR U)(U RU R) q/ DPD P b P
Hacer cambio aristas
R U L U R U L U V ps:: r i r i / WY ps:i
Reacomodar aristas dos arista en lado a cambiar (no una) arista gira hacia donde debe ir. (pescado acostado
Reloj
U R U L U R U L U2 AY i@/ W ps::r i r
Anti reloj
U L U R U L U R U2 V ps::r i r i / MY i@

1. Hand - R or L.
2. Finger - 1, 2, 3, 4, 5 for thumb,index,middle,ring and pinky.
3. A or B, A for the front of the finger, B for the back.
4. Sticker - Conventional scheme or your BLD scheme (if you use Speffz, whatever suits you really), example, DFR would
be F in my BLD scheme, so I would use F.
5. -Ps or -Pl for Push or Pull. Here, push means any turn away from you, while pull means any turn towards you. For
example, a U' with the left hand would be a pull while a U' with the right hand (the way right-handed OHers do it) would be
a push, I hope this is clear.
r for regrips (in the middle of an alg).
If you want to describe how you grip the cube while doing an alg instead of how you fingertrick it, you could use the same
notation except the Ps or Pl part.
Examples:
1. How I would do the last F' of the common T-perm:
R1AF-Ps (here I call F' a "push" as if you would do an x U' (which is F') it would be a push).
2. How I do the first F' of the Jb perm (R U R' F' R U R' U' R' F R2 U' R' U')
R2BF-Ps (kind of like a Japanese U')
3. D's in the E perm (x' R U' R' D R U R D' R U R' D R U' R' D' )
L4BL-Ps (in my BLD lettering scheme LBD is L)
The Ps - Pl can be confusing sometimes, in this case D would usually be called a push and D' would be a pull, but if we
go by the "towards-you away-from-you" logic D' would be a push and D would be a pull.

Today, Id like to discuss a topic that has been of interest to me for a few years now. We love to share our
favorite algs for certain cases of methods, and many of us share the same algs, but use completely
different methods of execution. What I would like to see, is something that hasnt been available to us,
and that is the ability to use simple notation to express finger-tricks.
Now, a few methods have been proposed in this thread. But unfortunately, there appears to be nothing
practical or standard for expressing finger-tricks.
Now, why is that? It is because finger-tricks involve many variables, and many of the proposed notations
attempt to over-describe certain attributes of a finger-trick (for example which face the finger is on,
font/back of finger). And many of them attempt to make a notation for every finger, when most of the
time, we use very few (for example, I mostly use my thumbs and pointer fingers). Another thing that is
also done is attempting to describe the finger-trick for every move, but this is unnecessary with something
like R U R U. There is also the problem of which hand is in use with each trick. With these issues, many
finger-trick notations quickly become impractical to learn.
So what could be the solution to all these problems? Something Ive thought about is the use of
assumptive notation, meaning that, using only one piece of data, the rest can be assumed. Example, if I
wanted to say that the move U is done with the index finger, which index finger would you guess it should
be? Where would that index finger push?
Some of us (at least I) would say that the left index finger pushes (or pulls) from the back. But if someone
else finds it easier to use the right finger (perhaps depending on the grip at the moment of the
movement), they can assume the right one. And this choice might also be dependent on the finger-tricks
leading up to that move, or (in rare cases) the finger-tricks following.
This also works with moves that have no notation at all. For example with R U R U would could put: R
(indexFingerNotation)U R (indexFingerNotation)U. From that we can assume that R and R are regular
turns and that U is done with the right pointer finger, and U with the left. We can even assume the correct
grip for the first R because of the indicated finger for U (In this case, thumb on bottom, rest on top).
Regrips would be assumed the same way, the cuber deciding where he is most comfortable with the
movement.
Now, why would this work? Because the point of finger tricks is to make an algorithm easier and faster to
execute. By using assumptive notation, one would almost automatically choose the easiest and smoothest
way to execute said move based on his or her needs and natural tendencies (what is comfortable). And if
the extra information is necessary (example, a finger-trick combo that is strange and unusual, but
perhaps faster than whats comfortable when youre used to it) then it could be added. But when such is
unnecessary, it should be excluded.
Why wouldn't it work? Because the point of finger-trick notation is to be more specific about the execution
of an alg, and someone who assumes wrongly might do something that was not intended by the writer of
the alg. And if we assume too much, then the reader might not be able to assume certain things that we
want them to do without a little extra information like a regrip or certain piece's side on which to push.
Now while the need of this information is rare, you'll never know when someone wants to share a very
different but perhaps effective method. So what could we do to help that? Add some symbols to the
notation, and only use them when needed. Done.

Here is an example notation that can be used to demonstrate what Im talking about (it is not yet fully
developed):

Simple Notation:
< = either index finger (> = left index finger if you really need to specify)
^ = thumb
. = pinkie finger (pinkie finger and ring finger are interchangeable)
- = ring finger
* = middle finger
For _2 moves, two notations can go before the movement.
Extra Notation (only when necessary):
: = regrip
/ = use right finger
\ = use left finger
etc. you come up with some others, but only if necessary to avoid confusion.

Lets apply it to sexy move:


-R <U R <U
Now lets have a few other simple examples:
R ^U R <U
<U R <U R .U R ^<U2 R (assumed regrip after <U)
R -D R <F
-*M2 <U -*M2 <*U2 -*M2 <U -*M2 (judging by the odd combination of fingers here, we can assume that
its using certain fingers on one hand, and certain fingers on the other)
How about a few odd ones to show perhaps some weaknesses in this notation, or some new ways that
finger-tricks could be done:
R ^B <D (This one is odd because look at where youre hand ends up if you follow it assumptively)
<L U <L U <L U2 <L (Try to figure out a smooth way to do that. Hint: Right hand moves up. Heres the
same one using the left index finger notation: >L U <L U >L U2 <L)
*d (normal) ^d (using a thumb) -*d2 (strange but smooth)

These are just a few examples of what could be conveyed through an assumptive notation for fingertricks.
If something like this could catch on and be implemented, then we could share some of the ways we do
certain algs, and compare them to find the best match for us.