Talk:Crazy J

How did you find these expressions?

I am wondering how you found these expressions. Some of them seem shorter than expected. For example, suppose I want to derive S from J and I. I look at the formula Sxyz=xz(yz). I want to make xz(yz) start with the same thing in xz and yz, so I can use J. One way to do this is Tzx(Tzy)=Tzx(TzTy)=J(Tz)xyT. I know that T=JII. Then, I want to bring Tz out of the parentheses. I could use B, but that would be complicated. An easy way to do this is to use IJ(ITz)xyT=JIJzTxyT. Then, I want to use permuters to bring the xyz to the end. Here are some birds that will help.

R₁xyzw=ywzx

R₂xyzwv=ywvzx

R₃xyzwvu=yuwvzx

It is easy to see that R₁=JR, R₂=JR₁, R₃=JR₂.

JRxyzw=Rx(Rży)w=Rzywx=ywzx

JR₁xyzwv=R₁x(R₁zy)wv=R₁zyvwx=ywvzx

JR₂xyzwvu=R₂x(R₂zy)wvu=R₂zyvuwx=yuwvzx

Therefore, R₁=J(J(JII)), R₂=J(J(J(JII))), R₃=J(J(J(J(JII)))). Now, we can bring z to the end of JIJzTxyT using R₃ to get R₃T(JIJ)yTxz. Then, we can bring y to the end with R₁ to get R₁xT(R₃T(JIJ))yz. Then, we can bring x to the end with R₁ to get R₁TR₁(R₃T(JIJ))xyz. Then, S=R₁TR₁(R₃T(JIJ)).

R₁TR₁(R₃T(JIJ))xyz=R₁xT(R₃T(JIJ))yz=R₃T(JIJ)yTxz=JIJzTxyT=IJ(ITz)xyT=J(Tz)xyT=Tzx(TzTy)=Tzx(Tzy)=xz(yz)

Therefore, S=J(J(JII))(JII)(J(J(JII)))(J(J(J(J(JII))))(JII)(JIJ)). However, this has 26 letters, and your expression has 19 letters. How did you find your expression?

By the way, I have reinstated V* in your list. The correct formula is V*xyzw=xwyz. You originally had xzyw, which is a cardinal extended to 4 variables (Cxyzw=xzyw). Your expression was equivalent to RRR=J(JII)(J(JII))(J(JII)). V* can be derived from R₁ as R₁R₁R₁R₁.

R₁R₁R₁R₁xyzw=R₁xR₁R₁yzw=R₁yR₁xzw=R₁zxyw=xwyz

Therefore, V*=J(J(JII))(J(J(JII)))(J(J(JII)))(J(J(JII))). Is this the shortest expression? --(this comment by Bobby Jacobs at 13:38, 27 June 2026 UTC; please sign your comments with ~~~~)

For the shortest ones I use bruteforce (I can publish the source code if you're interested, it's in C++). Your approach for manual IJ abstraction elimination is similar to mine which is described in the article (section 5.4). Regarding V*: I just started my bruteforcer, and it quickly found this (length 15): J(J(J(JII)(J(J(JII))))I)IJI. --Blashyrkh (talk) 13:52, 27 June 2026 (UTC)

Regarding your R_n approach: I did try this way, but was disappointed by R₂ already, and abandoned it (while kept R and R₁). However, looking at your derivations now, I rather believe it might be promising. My way to move bound variable to the position suitable for eta-reduction buries other variables too deeply. Probably, R_n approach might produce more optimal code. --Blashyrkh (talk) 14:45, 28 June 2026 (UTC)

Made some derivations:

R 1 2 3 = 2 3 1                                - offset = 1, size = 4 - my R-rule
R1 1 2 3 4 = 2 4 3 1                           - offset = 2, size = 5 - my JR-rule
R2 1 2 3 4 5 = 2 4 5 3 1                       - offset = 2, size = 6, at this point I dropped the idea last time
R3 1 2 3 4 5 6 = 2 6 4 5 3 1                   - offset = 4, size = 7 - new rule candidate!
R4 1 2 3 4 5 6 7 = 2 4 5 6 7 3 1               - offset = 2, size = 8
R5 1 2 3 4 5 6 7 8 = 2 6 7 8 4 5 3 1           - offset = 4, size = 9
R6 1 2 3 4 5 6 7 8 9 = 2 5 6 4 8 9 7 3 1       - offset = 3, size = 10
R7 1 2 3 4 5 6 7 8 9 10 = 2 5 9 7 8 4 10 6 3 1 - offset = 3, size = 11

So, R₃ is really a worthy finding, but others... idk. --Blashyrkh (talk) 19:30, 28 June 2026 (UTC)

This is really interesting. Sorry I forgot to sign my earlier post. Bobby Jacobs (talk) 14:35, 12 July 2026 (UTC)

Your R_n approach gave me an idea for bruteforce. I'll search for expressions in the form C1,1 ... C1,k1 x C2,1 ... C2,k2 y ... (where C stands for "constant") that reduce to a permutation of x, y,..., index them by actual performed permutations and optimize by SUM(LEN(Ci,j)). I suppose T, R, R₁ and R₃ are going to be found quickly, and I also hope that some other useful (and non-trivial) equations are going to be found as well. --Blashyrkh (talk) 08:44, 13 July 2026 (UTC)