From:

~~~ ~~~ Subject:

I have mentioned several times my discomfort about "an operator"

as opposed to "the thing being operated on" when it comes to

groups. I am never quite sure just which of the two it is

that people are talking about, even (or especially) when I am listening

to myself talk. There is clearly an essential duality between the

two, but I am not sure I have quite a strong enough group theory

background to fully understand it. I am very comfortable when the

operators form a group, but I am not very comfortable when the things

being operated on form a group.

I am presently rereading (hopefully VERY SLOWLY

AND VERY CAREFULLY) Dan Hoey and Jim Saxe's seminal paper from

December 1980 entitled Symmetry and Local Maxima. Here is a quote

from their paper.

We will sometimes (particularly towards the end of this message)

take the liberty of identifying a transformation with the position

reached by applying that transformation to SOLVED.

Well, I am beginning to think that the source of my discomfiture

is simply that everybody does the same thing all the time, and that

nobody ever makes the identification explicit. However, I think that

maybe the duality is there, whether the identification is explicit,

implicit, or not made at all. Let me see if I can make clear what I

mean with some non-cubing programming examples.

When I first started computer cubing, I was struck by the fact that

(at least with my model of the cube), the computer code to implement

a permutation operation looked exactly like the computer code to

translate between various character codes. For example, I have had

frequent occasion to translate between ASCII and EBCDIC (in both

directions). The code to translate between the ASCII string X and

the EBCDIC string Y is something like

for i = 1 to n Y(i) = T(X(i))

where T is the translate table. To make this clear by an example,

the ASCII code for the letter A is decimal 33 and the EBCDIC code

for the letter A is decimal 193. Hence, the 33-rd position of T

contains decimal 193, and the 193-rd position of T' contains 33.

Beyond this simple little loop above, many (if not most) programming

languages have a function (often called TRANSLATE or TRANSFORM) which

does exactly the same thing. There are also hardware architectures

which implement the TRANSLATE in hardware. For example, you might

have something like

Y = TRANSLATE(X,T)

where X is the string to be translated and T is the translate table.

X and T are clearly not interchangeable as input to the TRANSLATE

function. However, (and repeating myself) I think there is an

essential duality between X and T. For example, consider what

would happen if you reversed the role of X and T as follows. Let X

be the hexadecimal string 010201020301020403. Then,

Y = TRANSLATE(X,' ABC') would yield the string ' A AB ACB'. Such

a role reversal for the "permutation operator" and "permutation operatee"

can be a very powerful programming technique. For example, I have

used it to redistribute data, creating well-formatted print lines or

well-formatted display screens (text mode) with one fell swoop (with

only a single invocation of the TRANSLATE function).

I am going to continue reading, but perhaps I could pose a question to

Dan Hoey anyway: is reversing the role of X and T in the TRANSLATE

function above essentially the same thing as switching between

pre-multiplication and post-multiplication?

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Robert G. Bryan (Jerry Bryan) (304) 293-5192 Associate Director, WVNET (304) 293-5540 fax 837 Chestnut Ridge Road BRYAN@WVNVM Morgantown, WV 26505 BRYAN@WVNVM.WVNET.EDU

If you don't have time to do it right today, what makes you think you are

going to have time to do it over again tomorrow?