[Question]
  [
**Input**
Integers a1, a2, a3, b1, b2, b3 each in the range 1 to 20.
**Output**
```
True if a1^(a2^a3) > b1^(b2^b3) and False otherwise.
```
^ is exponentiation in this question.
**Rules**
This is code-golf. Your code must terminate correctly within 10 seconds for any valid input on a standard desktop PC. 
You can output anything Truthy for True and anything Falsey for False.
You can assume any input order you like as long as its specified in the answer and always the same.
For this question your code should always be correct. That is it should not fail because of floating point inaccuracies. Due to the limited range of the input this should not be too hard to achieve.
**Test cases**
```
3^(4^5) > 5^(4^3)
1^(2^3) < 3^(2^1)
3^(6^5) < 5^(20^3)
20^(20^20) > 20^(20^19)
20^(20^20) == 20^(20^20)
2^2^20 > 2^20^2
2^3^12 == 8^3^11
1^20^20 == 1^1^1
1^1^1 == 1^20^20
```
  
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~31~~ 29 bytes
*-2 bytes thanks to Grimy*
```
*.log10* * ***>*.log10* * ***
```
[Try it online!](https://tio.run/##VYvRCsIwDEXf@xV5EGkr2KZ1Q53bl0hBcB2Dzsn2NNRvrwkIMgLJuZeTZzulMg8LbGOd9T6NHVoNNFo365grEccJZOof7azgJQCGc2eu952piOfbAhHeGyM@2Qd5CIWCBgomrwQG6ejCpQbPiErQLVmiiixnWaPN5Cz//gKeVj3p/yRcoLEsB24o@4COpSMTfgE "Perl 6 – Try It Online")
Believe it or not, this is *not* an esolang, even if it is composed of mostly asterisks. This uses [Arnauld's formula](https://codegolf.stackexchange.com/a/184737/76162), with log10 instead of ln.
[Answer]
# [R](https://www.r-project.org/), 39 bytes
```
function(x,y,z)rank(log2(x)*(y^z))[1]<2
```
[Try it online!](https://tio.run/##dY7LTsMwEEX3@YqRurHRVOrYBYHUVGIBK1Y8VggkJ3Ueakgq44q0iG8PtqFpG6jHsq25Z66v6UZQ6GqlDWTrOrVlU4NtIFVVBbbQ@@ZHaQtQJl@/6dq@Q1kHWbcrnVq9gMYstIkyiPsJpgiVQCUxIUwEJpJ/5iz17YQ4uofrifCQXuRfUQ5x14@3uMEtN6pesqrJBWv5Gdu8bjl/ppeZ6DImcYrnrqYoOfyuEcxhPJ7D7fXdw02UMUKB0pVAOmBmgXm8f/KIxItgIyZ7nwHipMNNV/zvTwNGTAITH9m4GF4KB/8/sI9LAi/9RT1zZEO7GL5OIT@1CzJEum8 "R – Try It Online")
Returns FALSE when `a > b` and TRUE if `b < a`
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~11~~ ~~9~~ ~~11~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.²Šm*`›
```
Port of [*@Arnauld*'s JavaScript](https://codegolf.stackexchange.com/a/184737/52210) and [*@digEmAll*'s R](https://codegolf.stackexchange.com/a/184738/52210) approaches (I saw them post around the same time)  
-2 bytes thanks to *@Emigna*  
+2 bytes as bug-fix after *@Arnauld*'s and *@digEmAll*'s answers contained an error  
-4 bytes now that a different input order is allowed after *@LuisMendo*'s comments
Input as `[a1,b1]`, `[a3,b3]`, `[a2,b2]` as three separated inputs.
[Try it online](https://tio.run/##yy9OTMpM/f9f79CmowtytRIeNez6/z/aSMcolivayABC6RgZxAIA) or [verify all test cases](https://tio.run/##yy9OTMpM/W/hphSdaKiTZBhrq2Tv6RJqr6SjEJ1orJNkDBEIgwgY6SQZQQTsIyOUFB61TVJQsv@vd2jT0QW5WgmPGnb91/kfbaxjGssVbapjDCRNdEyApCGYbaxjCCSNdIzAbIQaMx0jA5CEAZw2tMTPx0@DLQDxIByImAXIGUY6hoZgy41jAQ).
**Explanation:**
```
.²       # Take the logarithm with base 2 of the implicit [a1,b1]-input
  Š      # Triple-swap a,b,c to c,a,b with the implicit inputs
         #  The stack order is now: [log2(a1),log2(b1)], [a2,b2], [a3,b3]
   m     # Take the power, resulting in [a2**a3,b2**b3]
    *    # Multiply it with the log2-list, resulting in [log2(a1)*a2**a3,log2(b1)*b2**b3]
     `   # Push both values separated to the stack
      ›  # And check if log2(a1)*a2**a3 is larger than log2(b1)*b2**b3
         # (after which the result is output implicitly)
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 56 bytes
```
(a,b,c,d,e,f)->a>Math.pow(d,Math.pow(e,f)/Math.pow(b,c))
```
[Try it online!](https://tio.run/##hVJdaoNAEH7vKQZBcGFjoyalSWj60OdAIY@Swqprahp/0E1CCR6g9@jJehE77rq2sYXALvPtzDfzjePs2JGNdtFbE@5ZVcGKJRmcbwCKMjkywSHJBC9jFnJ4zk94nvK0YCWXHIAgz/ecZRAqr4VsYLRNgkCZUJlIGa5MTBaYXrcyh2CfhFAJJtAc8ySCFFuw1qJMsq2/AVZuK9KpXXYQpgU8QGMxGtCQRpTTmIyWbLli4tUu8pMV0R62sdv@hXxCmoWsie34G9QRvBIV1lNKAGfwKEwoTOVB4EFN@5hDwaUtw5PA@R1D153Oc8eDxNYxvM7sGsMdXzCkpvR3ZhDFDhw09x0aNq5l1RlE@/NXdyZLOuqrJ8Oo9tGep6O1mnScl5actpz1XE2c9AMfrBL@CvzBtl6sluyPN1Rm@Y4GrgaeBhMNphuy6Eqv3yvBUzs/CBvXOhOxZZjRi4XXjAiYFfy8zMzo8v8X0909grE0YA7G18encb2HWq573XwD "Java (JDK) – Try It Online")
## Credits
* [@Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%c3%98rjan-johansen) for finding a bug in my solution.
* Saved 10 bytes by reusing [@tsh's advantageous operands agencing](https://codegolf.stackexchange.com/a/184819/16236).
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 23 bytes
```
#2^#3Log@#>#5^#6Log@#4&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277X9koTtnYJz/dQdlO2TRO2QzMNFH7H1CUmVei4JAebaxjomMKhCY6xrFccFFDHSMdYyA00jFEEjXWMQOrNTJAUQzkIiNDS9xyRgax//8DAA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~11~~ 9 bytes
```
>&(^.@^/)
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/7dQ04vQc4vQ1/2typSZn5CsYKtgqGCuYKJgqpAGxiYIxRNgAKGyoYASUSgNiIwVDhLCxghlUtZEBTDnIFCAPjCqAchC2oWUFQhumNJCNpBsEIZJguYr/AA "J – Try It Online")
Arguments given as lists.
* `>` is the left one bigger?
* `&(...)` but first, transform each argument thusly:
* `^.@^/` reduce it from the right to the left with exponention. But because ordinary exponentiation will limit error even for extended numbers, we take the logs of both sides
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 44 bytes
```
import StdEnv
$a b c d e f=b^c/e^f>ln d/ln a
```
[Try it online!](https://tio.run/##bY1BS8NAEIXPza94hx4UJrRJtCi0nvQgeLLHNIXJ7mwb2GxKsyr@eddNCLYHYXi8@fbNW2WFXWg7/WEFLTcuNO2pO3tsvX5xn8mcUUNBQ2A29V4tZG@erINeROGw9RyzG5RzXAWx26FkQk1QBE0QgqmwTuMPJ9wM4rt3YXsLL71X3EtfJV9HOcsFDK3JbFaiINwR7seJpqhoxBkhp@GxGE024bitpnS@/EtHez3Z4784X04l@VA5nE96wQVlUR9Gk1VV@FHG8qEP6etbeP523DYqLjakxnDv05b98Rc "Clean – Try It Online")
Uses an adaptation of Arnauld's formula.
[Answer]
# [Python 3](https://docs.python.org/3/), 68 bytes
```
lambda a,b,c,d,e,f:log(a,2)*(b**c)>log(d,2)*(e**f)
from math import*
```
[Try it online!](https://tio.run/##dY3NCsMgEITveQqPKnOImpa20D5JL@ZHE4hRxEuf3hqhkBzKLrvMN8Nu@KTZbypb8iTvvGrXj5po9BgwYoJ5rN5SDck47Tkf2GvXY9UT54Y1JnpHnE4zWVzwMfEc4rIlaqlCh0upDoqx5kcFJFQpCXGgCteale0pXOSxxf2/J9ujV87vrI4TVxASt32V9/kL "Python 3 – Try It Online")
Port of @Arnualds answer, but with the base for log changed. 
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 11 bytes
```
2(?9•??e*)>
```
I'm beginning to understand Vyxal.
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=2%28%3F9%E2%80%A2%3F%3Fe*%29%3E&inputs=3%0A2%0A1%0A1%0A2%0A3&header=&footer=)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
Uses the method from [Arnauld's JS answer](https://codegolf.stackexchange.com/a/184737/47066)
```
2F.²IIm*ˆ}¯`›
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fyE3v0CZPz1yt0221h9YnPGrYBRTjAkIDKAEA "05AB1E – Try It Online")
[Answer]
## Excel, 28 bytes
```
=B1^C1*LOG(A1)>E1^F1*LOG(D1)
```
Excel implementation of the same formula already used.
[Answer]
# JavaScript, 51 bytes
```
f=(a,b,c,h,i,j)=>(l=Math.log)(a)*b**c-l(h)*i**j>1e-8
```
~~Surprisingly, the test cases doesn't show any floating-point error. I don't know if it ever does at this size.~~
This just compares the logarithm of the numbers.
Equality tolerance is equal to `1e-8`.
[Answer]
# bc -l, 47 bytes
```
l(read())*read()^read()>l(read())*read()^read()
```
with the input read from `STDIN`, one integer per line.
`bc` is pretty fast; it handles a=b=c=d=e=f=1,000,000 in a little over a second on my laptop.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 86 bytes
Thanks to @ØrjanJohansen for pointing out a flaw in this and @Ourous for giving a fix.
```
#import<cmath>
int a(int i[]){return pow(i[1],i[2])/pow(i[4],i[5])>log(i[3])/log(*i);}
```
[Try it online!](https://tio.run/##hVPNboMwDD7DU3jdBVaqkv5pA1Zphx32DCgHlEKXigKCoE6rePV1doC1VKsKcuIv9ue/KKIoJlshTqdHuS/yUgViH6nPtSkzBZFFqwy5fSxjVZcZFPnBkiHjjgxn3J62cEFwye11mm8RztFA2pO0/QbDZiKtNzEEMq9UGUf7tamD7yOZWTYcTUMnyYpahRxe4Th3Fs4S/4Uzb/wLaxXycKU9AEwAMAx0BVigLDshfd44JpoYqjOCnZDOWhPB1QVr5jo9i9RrYS@3bTO3s3UZ9Fm/n02UkaHyjDsBxhrT6JvLa9V2R60hgxHN/VvYldYSk7yE9naQ5fq4BVDJ7zhPrHZY9nQAQ5fbPozHUk/cqNTG8wRmhiCA0Qe5eFgajDD0OfbO6ycvecsbEnea7bSsZhD23odE7Rxnm5Ti6pPR@1cRCxVvPBgR7icj@U3Gm1B1lFLtmhFZFwVfMqhCmWBb8PB6d1AwAfZfv4NodIOm0b0L1zeb049I0mhbnSaHXw "C++ (gcc) – Try It Online")
Takes input as a 6-integer array. Returns 1 if \$a^{b^c} > d^{e^f}\$, 0 otherwise.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
l⁵×*/}>/
```
[Try it online!](https://tio.run/##y0rNyan8/z/nUePWw9O19Gvt9P@HWx9aqv@oYa6GtUq4yqOmNUBkdGiZNVBEEy5gfGhZ1LGuLBCnYY6ClpYCUDbrUeM@HYVjXTogIV07kJDO4eX6XIfbgcoi//@P5oqONtZRMI3VUYiONtFRMAExTHUUjGNjY3WAcoYgJkjOSEfBCMQAKjaEysH1mQHlDNA0GhnABJGYIJahJSEVQBZUBdROMAMhDZWFuRbkDrAyIyTbdRQsYHLGUGcb4ZIzBIoYgjzFFQsA "Jelly – Try It Online")
Based on [Arnauld’s JS answer](https://codegolf.stackexchange.com/a/184737/42248). Expects as input `[a1, b1]` as left argument and `[[a2, b2], [a3, b3]]` as right argument. 
Now changed to use log to the base 10 which as far as correctly handles all the possible inputs in the range specified. Thanks to Ørjan Johansen for finding the original problem!
[Answer]
# TI-BASIC, ~~27~~ 31 bytes
```
ln(Ans(1))Ans(2)^Ans(3)>Ans(5)^Ans(6)(ln(Ans(4
```
Input is a list of length \$6\$ in `Ans`.  
Outputs true if the first big number is greater than the second big number. Outputs false otherwise.
**Examples:**
```
{3,4,5,5,4,3
   {3 4 5 5 4 3}
prgmCDGF16
               1
{20,20,20,20,20,19       ;these two lines go off-screen
{20 20 20 20 20 19}
prgmCDGF16
               1
{3,6,5,5,20,3
  {3 6 5 5 20 3}
prgmCDGF16
               0
```
**Explanation:**
```
ln(Ans(1))Ans(2)^Ans(3)>Ans(5)^Ans(6)(ln(Ans(4   ;full program
                                                 ;elements of input denoted as:
                                                 ; {#1 #2 #3 #4 #5 #6}
ln(Ans(1))Ans(2)^Ans(3)                          ;calculate ln(#1)*(#2^#3)
                        Ans(5)^Ans(6)(ln(Ans(4   ;calculate (#5^#6)*ln(#4)
                       >                         ;is the first result greater than the
                                                 ; second result?
                                                 ; leave answer in "Ans"
                                                 ;implicit print of "Ans"
```
---
**Note:** TI-BASIC is a tokenized language. Character count does ***not*** equal byte count.
[Answer]
# APL(NARS), chars 36, bytes 72
```
{>/{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b}¨⍺⍵}
```
Here below the function z in (a b c )z(x y t) would return 1 if a^(b^c)>x^(y^t) else would return 0;
test
```
  z←{>/{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b}¨⍺⍵}
  3 4 5 z 5 4 3
1
  1 2 3 z 3 2 1
0
  3 6 5 z 5 20 3
0
  20 20 20 z 20 20 19
1
  20 20 20 z 20 20 20
0
  2 2 20 z 2 20 2
1
  2 3 12 z 8 3 11
0
  1 20 20 z 1 1 1
0
  1 1 1 z 1 20 20
0
  1 4 5 z 2 1 1
0
```
{(a b c)←⍵⋄a=1:¯1⋄(⍟⍟a)+c×⍟b} is the function p(a,b,c)=log(log(a))+c\*log(b)=log(log(a^b^c))
and if aa=a^(b^c) with a,b,c >0 and a>1 bb=x^(y^t) with x,y,t >0 and x>1 than
```
aa>bb <=> log(log(a^b^c))>log(log(x^y^t))  <=>  p(a,b,c)>p(x,y,t)
```
There is a problem with the function p: When a is 1, log log 1 not exist so I choose to represent that with the number -1; when a=2 so log log a is a negative number but > -1 .
PS. Seen the function in its bigger set in which is defined
```
p(a,b,c)=log(log(a))+c*log(b)
```
appear range for a,b,c in 1..20 is too few... If one see when it overflow with log base 10, the range for a,b,c could be 1..10000000 or bigger for a 64 bit float type.
]