On 12/16/10, Bill Gosper <billgosper@gmail.com> wrote:

Simplifying with the aequatio abstrusa: EllipticK[1/(EllipticEta[q]^8/(16*EllipticEta[q^4]^8) + 1)] -> Pi*EllipticEta[q^2]^10/ (2*EllipticEta[q]^4*EllipticEta[q^4]^4) E.g., EllipticK[(2 + GoldenRatio^(3/2))/ (Sqrt[2 + Sqrt[5]] + GoldenRatio^(3/2))] -> (5/2)^(3/4) (5 + Sqrt[5])^(1/4) Gamma[9/20] Gamma[21/20]/Sqrt[Pi]

DAWK! Rich points out this lhs is just EllipticK[1/2 + GoldenRatio^-(3/2)] . Now that's almost unexotic! Betcha EllipticK[1/2 - GoldenRatio^-(3/2)] comes out similarly. --rwg

Then for negative m->m/(m-1): EllipticK[-16 EllipticEta[q^4]^8/EllipticEta[q]^8] -> Pi EllipticEta[q]^4/(2 EllipticEta[q^2]^2)

E.g., EllipticK[-((2 + GoldenRatio^(3/2))/(-2 + Sqrt[2 + Sqrt[5]]))] -> 5/21 5^(5/8) Sqrt[(2 (2 (-5 + Sqrt[5]) + Sqrt[10 (1 + Sqrt[5])]))/Pi] Gamma[9/20] Gamma[41/20]

I wonder if there are any valuations for less exotic "K-ands". There's a quadratic transformation leading to K(17-12 rt2) (Little League Home Plate! http://mathworld.wolfram.com/HomePlate.html) But I doubt it would simplify any of these weirdos. --rwg

On Wed, Dec 15, 2010 at 6:33 PM, Bill Gosper <billgosper@gmail.com> wrote:

...

For a horizontally swung pendulum (thetamax = pi/2), the Fourier series for am gives instead a fundamental of 4 sech(pi/2) = 1.594, exceeding pi/2 by < 2%. The "sechand" pi/2 fell out of some EllipticKs whose values were among the few currently known to FunctionExpand.

But my more-or-less systematic collection of special values of eta provides an abundance of K values, because

EllipticK[EllipticTheta[2, 0, q]^4/EllipticTheta[3, 0, q]^4] -> 1/2 Pi EllipticTheta[3, 0, q]^2 , i.e.,

EllipticK[(16 EllipticEta[q]^8 EllipticEta[q^4]^16)/EllipticEta[q^2]^24] -> Pi EllipticEta[q^2]^10/(2 EllipticEta[q]^4 EllipticEta[q^4]^4) ,

where EllipticEta[q_] -> EllipticTheta[1, \[Pi]/3, q^(1/6)]/Sqrt[3] ,

I.e., DedekindEta[tau]->EllipticEta[Exp[2*I*Pi*tau]]

E.g., EllipticK[1/2 + Sqrt[2] 3^(1/4) (-2 + Sqrt[3])] -> Gamma[1/4]^2/(2 3^(3/4) (-1 + Sqrt[3]) Sqrt[2 Pi]),

EllipticK[1/2 - Sqrt[2] 3^(1/4) (-2 + Sqrt[3])] -> 3^(1/4) Gamma[1/4]^2/(2 (-1 + Sqrt[3]) Sqrt[2 Pi]),

EllipticK[1 - (-2 + Sqrt[2] - Sqrt[3] + Sqrt[6])^4] -> 3^(3/4) Gamma[1/3]^3)/ (2 2^(5/6) (1 + Sqrt[3])^(5/2) Sqrt[-3 - 4 Sqrt[2] + 5 Sqrt[3]] Pi)

EllipticK[8 2^(1/4) (9 - 4 2^(1/4) - 3 Sqrt[2]))/(-1 + Sqrt[2])^6] -> (-1 + Sqrt[2])^(5/2) Gamma[1/4]^2/(4 Sqrt[2 (9 - 4 2^(1/4) - 3 Sqrt[2]) Pi])

EllipticK[-16 + 12 Sqrt[2]] -> 2 (2 + Sqrt[2]) Gamma[5/4]^2)/Sqrt[Pi] --rwg

I have found an interesting bijection between trees (binary trees, not Christmas trees!) and natural numbers, allowing numbers to be displayed as trees, and trees to be associated with numbers. This gives a nice, fun alternative to our positional notation for writing numbers. The rules are very simple: * Let the single-point tree, (), be designated the value 0. * Let the tree (XY) be designated the value ((x+y)²+3x+y+2)/2, where x and y are the values corresponding to the trees X and Y, respectively. In full parenthetic notation, the first few trees are: 0 () 1 (()()) 2 (()(()())) 3 ((()())()) 4 (()(()(()()))) 5 ((()())(()())) ... Using the more compact notation of expressing () as * and (XY) as #XY, the trees then become: 0 * 1 #** 2 #*#** 3 ##*** 4 #*#*#** 5 ##**#** ... And removing the final asterisk results in: 0 (empty string) 1 #* 2 #*#* 3 ##** 4 #*#*#* 5 ##**#* ... This also serves as an enumeration of Dyck words. Now, if we replace # with ( and * with ), we have an enumeration of parenthetic statements: 0 (empty string) 1 () 2 ()() 3 (()) 4 ()()() 5 (())() ... This gives us another enumeration of trees (this time, not restricted to binary trees). For example, the balanced ternary tree: (()()())(()()())(()()()) can be reverse-engineered into the Dyck word: ##*#*#**##*#*#**##*#*#** and the binary tree: ##*#*#**##*#*#**##*#*#*** with the full parenthetic expansion: ((()(()(()())))((()(()(()())))((()(()(()())))()))) So, this is a simple bijection between the set of binary trees and the set of all trees, without having to convert to and from integer notation. We can go further, by allowing more than one type of root node (and slightly altering the 'composition' formula). Letting K = 0, S = 1, and `XY = ((x+y)²+3x+y+4)/2, we have the following: 0 K 1 S 2 `KK 3 `KS 4 `SK 5 `K`KK ... Ooh, an enumeration of SK-calculus supercombinators. This gets interesting! (` denotes the application operator) We can express I as `S`KK, or 9. `S`II then becomes 16389. The number 537231422 corresponds to the irreducible term, ``S`II`S`II. However, this is not very efficient for unbalanced binary trees. The fixed-point combinator, Y', becomes: 20330403641472985212299390532838786314945647725862859321210046999865821897931 (This is larger than the order of the Monster Group, but smaller than the number of atoms in the Universe.) So, this is a programming language, where each valid program is an integer, and vice-versa. The rules for an interpreter are as follows, in pseudocode: (WARNING: May not be suitable for programmers who insist on elegance!) combinator interpret(int n) { combinator r; if (n == 0) { r = K; } if (n == 1) { r = S; } if (n > 1) { int a = 0; while ((n - (2 + a))*8 + 1 is not a perfect square) // A beautiful test for triangular numbers! { increment a; // Exit when n - (2 + a) is a triangular number. } b = (sqrt((n - (2 + a))*8 + 1)-1)/2 - a; // This retrieves the side length of a triangular number. r = apply(interpret(a),interpret(b)) // Recursively call the interpreter on the two sub-terms. } return r; // Return the combinator corresponding to the value, n. } Merry Christmas! Sincerely, Adam P. Goucher

Neat! That particular bijection's well-know to those who know it, but I hadn't seen the pairing function before.

The pairing function is similar to Cantor's surjective mapping from integers to rationals, and appears in a footnote of The Emperor's New Mind (Penrose). (I re-discovered this pairing when I wanted a way to express an unbounded two-dimensional array of bits in an unbounded one- dimensional array, by converting between the pair of indices and a single index. This was necessary for me to store an unbounded array of naturals, which are themselves unbounded binary strings, in a one-dimensional tape for a computer in Conway's Game of Life.)

You may also enjoy Chris Barker's Iota, Jot and Zot: http://semarch.linguistics.fas.nyu.edu/barker/Iota/

Thank you very much! I only had a broken link before to Iota and Jot, and had never even heard of Zot.

as well as John Tromp's Binary Lambda Calculus and Binary Combinatory Logic: http://homepages.cwi.nl/~tromp/cl/cl.html

Yes, I've seen this before. Very elegant! (I prefer BCL to BLC, as it is simpler, despite being less efficient.)

My own design, Keraia, is here: http://arxiv.org/abs/cs/0508056

Ooh, interesting! I like your approach of considering Turing machines as being functions between strings, rather than the original formulation (which includes the state and position of the read/write head). Sincerely, Adam P. Goucher