[Question]
  [
Write a mathematical statement, using the symbols:
* `There exists at least one non-negative integer` (written as `E`, existential quantifier)
* `All non-negative integers`(written as `A`, universal quantifier)
* `+` (addition)
* `*` (multiplication)
* `=` (equality)
* `>`, `<` (comparison operators)
* `&`(and), `|`(or), `!`(not)
* `(`, `)` (for grouping)
* variable names
which is equivalent to the statement
> 
> There exists a rational number a, such that π + e \* a is rational.
> 
> 
> 
(of course, \$\pi =3.1415...\$ is the mathematical constant equal to the circumference divided by the diameter of a circle, and \$e=2.7182...\$ is [Euler's number](https://en.wikipedia.org/wiki/E_(mathematical_constant)))
You must prove that your statement is indeed equivalent to the statement above.
Obviously, the “shortest” way to go about this is to prove the statement true or false, and then answer with a trivially true or false statement, as all true statements are equivalent to one another, as are all false statements.
However, the given statement’s truth value is an [unsolved problem in mathematics](https://math.stackexchange.com/questions/159350/why-is-it-hard-to-prove-whether-pie-is-an-irrational-number): we don't even know if \$\pi+e\$ is irrational! Therefore, barring groundbreaking mathematical research, the challenge is to find a “simple” equivalent statement, prove its equivalence, and describe it as briefly as possible.
# Scoring
`E` `A` `+` `*` `=` `>` `<` `&` `|` and `!` each add 1 to the score. `(` and `)` don't add anything to the score. Each variable name adds 1 to the score.
E.g. `E x (A ba x+ba>x*(x+ba))` score 13 (`E` `x` `A` `ba` `x` `+` `ba` `>` `x` `*` `x` `+` `ba`)
Lowest score wins.
---
# Note:
Disclaimer: This note was not written by the OP.
* This is **not** a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge. Answers are not required to contain code.
* This is similar to, but not, a [proof-golf](/questions/tagged/proof-golf "show questions tagged 'proof-golf'") challenge, as you need to write a statement and prove it being equivalent to another statement.
* You are allowed to submit a trivially-true (e.g., for all x, x = x `Ax x=x`) or a trivially-false statement (e.g., for all x, x > x `Ax x>x`) if you can prove the statement above is true/false.
* You are allowed to use additional symbols (similar to lemma in proof-golf), but the score would be counted the same as you not using them.  
For example, if you define `a => b` to mean `(!a) | b`, each time you use `=>` in your proof, your score increases by 2.
* Because constants are not listed in the allowed symbols, you must not use them.  
For example: The statement `1 > 0` can be written as
```
Forall zero: ( zero + zero = zero ) =>
Forall one: ( Forall x: x * one = x ) =>
one > zero
```
at the score of 23. (remember that `=>` costs 2 per use).
# Hints
* To use natural constants, you may do `E0, 0+0=0 & E1, At 1*t=t &` (so you don't need `=>` which is more expansive); for numbers larger than 1, just add some 1's
  
[Answer]
# 671
`E a (a+a>a*a & (E b (E c (E d (A e (A f (f<a | (E g (E h (E i ((A j ((!(j=(f+f+h)*(f+f+h)+h | j=(f+f+a+i)*(f+f+a+i)+i) | j+a<e & (E k ((A l (!(l>a & (E m k=l*m)) | (E m l=e*m))) & (E l (E m (m<k & g=(e*l+(j+a))*k+m)))))) & (A k (!(E l (l=(j+k)*(j+k)+k+a & l<e & (E m ((A n (!(n>a & (E o m=n*o)) | (E o n=e*o))) & (E n (E o (o<m & g=(e*n+l)*m+o))))))) | j<a+a & k=a | (E l (E m ((E n (n=(l+m)*(l+m)+m+a & n<e & (E o ((A p (!(p>a & (E q o=p*q)) | (E q p=e*q))) & (E p (E q (q<o & g=(e*p+n)*o+q))))))) & j=l+a+a & k=j*j*m))))))) & (E j (E k (E l ((E m (m=(k+l)*(k+l)+l & (E n (n=(f+m)*(f+m)+m+a & n<e & (E o ((A p (!(p>a & (E q o=p*q)) | (E q p=e*q))) & (E p (E q (q<o & j=(e*p+n)*o+q))))))))) & (A m (A n (A o (!(E p (p=(n+o)*(n+o)+o & (E q (q=(m+p)*(m+p)+p+a & q<e & (E r ((A s (!(s>a & (E t r=s*t)) | (E t s=e*t))) & (E s (E t (t<r & j=(e*s+q)*r+t))))))))) | m<a & n=a & o=f | (E p (E q (E r (!(E s (s=(q+r)*(q+r)+r & (E t (t=(p+s)*(p+s)+s+a & t<e & (E u ((A v (!(v>a & (E w u=v*w)) | (E w v=e*w))) & (E v (E w (w<u & j=(e*v+t)*u+w))))))))) | m=p+a & n=(f+a)*q & o=f*r)))))))) & (E m (m=b*(h*f)*l & (E n (n=b*(h*f+h)*l & (E o (o=c*(k*f)*i & (E p (p=c*(k*f+k)*i & (E q (q=d*i*l & (m+o<q & n+p>q | m<p+q & n>o+q | o<n+q & p>m+q))))))))))))))))))))))))))`
### How it works
First, multiply through by the purported common denominators of a and (π + e·a) to rewrite the condition as: there exist a, b, c ∈ ℕ (not all zero) with a·π + b·e = c or a·π − b·e = c or −a·π + b·e = c. Three cases are necessary to deal with sign issues.
Then we’ll need to rewrite this to talk about π and e via rational approximations: for all rational approximations π₀ < π < π₁ and e₀ < e < e₁, we have a·π₀ + b·e₀ < c < a·π₁ + b·e₁ or a·π₀ − b·e₁ < c < a·π₁ + b·e₀ or −a·π₁ + b·e₀ < c < −a·π₀ + b·e₁. (Note that we now get the “not all zero” condition for free.)
Now for the hard part. How do we get these rational approximations? We want to use formulas like
2/1 · 2/3 · 4/3 · 4/5 ⋯ (2·k)/(2·k + 1) < π/2 < 2/1 · 2/3 · 4/3 · 4/5 ⋯ (2·k)/(2·k + 1) · (2·k + 2)/(2·k + 1),
((k + 1)/k)k < e < ((k + 1)/k)k + 1,
but there’s no obvious way to write the iterative definitions of these products. So we build up a bit of machinery that I first described in [this Quora post](https://www.quora.com/How-is-power-of-10-represented-in-Hofstadters-Typographical-Number-Theory/answer/Anders-Kaseorg?srid=uXs). Define:
divides(d, a) := ∃b, a = d·b,
powerOfPrime(a, p) := ∀b, ((b > 1 and divides(b, a)) ⇒ divides(p, b)),
which is satisfied iff a = 1, or p = 1, or p is prime and a is a power of it. Then
isDigit(a, s, p) := a < p and ∃b, (powerOfPrime(b, p) and ∃q r, (r < b and s = (p·q + a)·b + r))
is satisfied iff a = 0, or a is a digit of the base-p number s. This lets us represent any finite set using the digits of some base-p number. Now we can translate iterative computations by writing, roughly, there exists a set of intermediate states such that the final state is in the set, and every state in the set is either the initial state or follows in one step from some other state in the set.
Details are in the code below.
### Generating code in [Haskell](https://www.haskell.org/)
```
{-# LANGUAGE ImplicitParams, TypeFamilies, Rank2Types #-}
-- Define an embedded domain-specific language for propositions.
infixr 2 :|
infixr 3 :&
infix 4 :=
infix 4 :>
infix 4 :<
infixl 6 :+
infixl 7 :*
data Nat v
  = Var v
  | Nat v :+ Nat v
  | Nat v :* Nat v
instance Num (Nat v) where
  (+) = (:+)
  (*) = (:*)
  abs = id
  signum = error "signum Nat"
  fromInteger = error "fromInteger Nat"
  negate = error "negate Nat"
data Prop v
  = Ex (v -> Prop v)
  | Al (v -> Prop v)
  | Nat v := Nat v
  | Nat v :> Nat v
  | Nat v :< Nat v
  | Prop v :& Prop v
  | Prop v :| Prop v
  | Not (Prop v)
-- Display propositions in the given format.
allVars :: [String]
allVars = do
  s <- "" : allVars
  c <- ['a' .. 'z']
  pure (s ++ [c])
showNat :: Int -> Nat String -> ShowS
showNat _ (Var v) = showString v
showNat prec (a :+ b) =
  showParen (prec > 6) $ showNat 6 a . showString "+" . showNat 7 b
showNat prec (a :* b) =
  showParen (prec > 7) $ showNat 7 a . showString "*" . showNat 8 b
showProp :: Int -> Prop String -> [String] -> ShowS
showProp prec (Ex p) (v:free) =
  showParen (prec > 1) $ showString ("E " ++ v ++ " ") . showProp 4 (p v) free
showProp prec (Al p) (v:free) =
  showParen (prec > 1) $ showString ("A " ++ v ++ " ") . showProp 4 (p v) free
showProp prec (a := b) _ =
  showParen (prec > 4) $ showNat 5 a . showString "=" . showNat 5 b
showProp prec (a :> b) _ =
  showParen (prec > 4) $ showNat 5 a . showString ">" . showNat 5 b
showProp prec (a :< b) _ =
  showParen (prec > 4) $ showNat 5 a . showString "<" . showNat 5 b
showProp prec (p :& q) free =
  showParen (prec > 3) $
  showProp 4 p free . showString " & " . showProp 3 q free
showProp prec (p :| q) free =
  showParen (prec > 2) $
  showProp 3 p free . showString " | " . showProp 2 q free
showProp _ (Not p) free = showString "!" . showProp 9 p free
-- Compute the score.
scoreNat :: Nat v -> Int
scoreNat (Var _) = 1
scoreNat (a :+ b) = scoreNat a + 1 + scoreNat b
scoreNat (a :* b) = scoreNat a + 1 + scoreNat b
scoreProp :: Prop () -> Int
scoreProp (Ex p) = 2 + scoreProp (p ())
scoreProp (Al p) = 2 + scoreProp (p ())
scoreProp (p := q) = scoreNat p + 1 + scoreNat q
scoreProp (p :> q) = scoreNat p + 1 + scoreNat q
scoreProp (p :< q) = scoreNat p + 1 + scoreNat q
scoreProp (p :& q) = scoreProp p + 1 + scoreProp q
scoreProp (p :| q) = scoreProp p + 1 + scoreProp q
scoreProp (Not p) = 1 + scoreProp p
-- Convenience wrappers for n-ary exists and forall.
class OpenProp p where
  type OpenPropV p
  ex, al :: p -> Prop (OpenPropV p)
instance OpenProp (Prop v) where
  type OpenPropV (Prop v) = v
  ex = id
  al = id
instance (OpenProp p, a ~ Nat (OpenPropV p)) => OpenProp (a -> p) where
  type OpenPropV (a -> p) = OpenPropV p
  ex p = Ex (ex . p . Var)
  al p = Al (al . p . Var)
-- Utility for common subexpression elimination.
cse :: Int -> Nat v -> (Nat v -> Prop v) -> Prop v
cse uses x cont
  | (scoreNat x - 1) * (uses - 1) > 6 = ex (\x' -> x' := x :& cont x')
  | otherwise = cont x
-- p implies q.
infixl 1 ==>
p ==> q = Not p :| q
-- Define one as the unique n with n+n>n*n.
withOne ::
     ((?one :: Nat v) =>
        Prop v)
  -> Prop v
withOne p =
  ex
    (\one ->
       let ?one = one
       in one + one :> one * one :& p)
-- a is a multiple of d.
divides d a = ex (\b -> a := d * b)
-- a is a power of p (assuming p is prime).
powerOfPrime a p = al (\b -> b :> ?one :& divides b a ==> divides p b)
-- a is 0 or a digit of the base-p number s (assuming p is prime).
isDigit a s p =
  cse 2 a $ \a ->
    a :< p :&
    ex
      (\b -> powerOfPrime b p :& ex (\q r -> r :< b :& s := (p * q + a) * b + r))
-- An injection from ℕ² to ℕ, for representing tuples.
pair a b = (a + b) ^ 2 + b
-- πn₀/πd < π/4 < πn₁/πd, with both fractions approaching π/4 as k
-- increases:
-- πn₀ = 2²·4²·6²⋯(2·k)²·k
-- πn₁ = 2²·4²·6²⋯(2·k)²·(k + 1)
-- πd = 1²⋅3²·5²⋯(2·k + 1)²
πBound p k cont =
  ex
    (\s x πd ->
       al
         (\i ->
            (i := pair (k + k) x :| i := pair (k + k + ?one) πd ==>
             isDigit (i + ?one) s p) :&
            al
              (\a ->
                 isDigit (pair i a + ?one) s p ==>
                 ((i :< ?one + ?one :& a := ?one) :|
                  ex
                    (\i' a' ->
                       isDigit (pair i' a' + ?one) s p :&
                       i := i' + ?one + ?one :& a := i ^ 2 * a')))) :&
       let πn₀ = x * k
           πn₁ = πn₀ + x
       in cont πn₀ πn₁ πd)
-- en₀/ed < e < en₁/ed, with both fractions approaching e as k
-- increases:
-- en₀ = (k + 1)^k * k
-- en₁ = (k + 1)^(k + 1)
-- ed = k^(k + 1)
eBound p k cont =
  ex
    (\s x ed ->
       cse 3 (pair x ed) (\y -> isDigit (pair k y + ?one) s p) :&
       al
         (\i a b ->
            cse 3 (pair a b) (\y -> isDigit (pair i y + ?one) s p) ==>
            (i :< ?one :& a := ?one :& b := k) :|
            ex
              (\i' a' b' ->
                 cse 3 (pair a' b') (\y -> isDigit (pair i' y + ?one) s p) ==>
                 i := i' + ?one :& a := (k + ?one) * a' :& b := k * b')) :&
       let en₀ = x * k
           en₁ = en₀ + x
       in cont en₀ en₁ ed)
-- There exist a, b, c ∈ ℕ (not all zero) with a·π/4 + b·e = c or
-- a·π/4 = b·e + c or b·e = a·π/4 + c.
prop :: Prop v
prop =
  withOne $
  ex
    (\a b c ->
       al
         (\p k ->
            k :< ?one :|
            (πBound p k $ \πn₀ πn₁ πd ->
               eBound p k $ \en₀ en₁ ed ->
                 cse 3 (a * πn₀ * ed) $ \x₀ ->
                   cse 3 (a * πn₁ * ed) $ \x₁ ->
                     cse 3 (b * en₀ * πd) $ \y₀ ->
                       cse 3 (b * en₁ * πd) $ \y₁ ->
                         cse 6 (c * πd * ed) $ \z ->
                           (x₀ + y₀ :< z :& x₁ + y₁ :> z) :|
                           (x₀ :< y₁ + z :& x₁ :> y₀ + z) :|
                           (y₀ :< x₁ + z :& y₁ :> x₀ + z))))
main :: IO ()
main = do
  print (scoreProp prop)
  putStrLn (showProp 0 prop allVars "")
```
[Try it online!](https://tio.run/##pVhfbxvHEX/np5gyhnlHikwsyXJLiDSUxg0CBLZRJ3mxHWPvuJK2JO9Ot0eJVNXCKlogQJ/7OQr4xe/6Av4O/iLuzOzu3d6RlOpEgMjb@b@zv5md46nQUzmbffr01/4X8P3R029/PPr2CXw3z2YqVsVzkYu53oEfVpn8k5irmZK4@rNIprtE0vBF/2@tVr8P38hjlUgQCch5JCcTOYFJOhcq6etMxupYxTATyclCnEg4TnPI8jRLtSpUmuhBSyXHapnDLgyvWm6xB8P7dgH7MBx5z2Pv@dA@z@AAhr1y8QiG3VZrIgoBT0UB5y2AEfwkcn66MjSUL5klqWtJaEgXIoklPF3MIWBiCBenMpcoHvRCtBcMeyEtumbRpYWINC7UBB@1OklQdwQyz3HLbbtGU23kHufp/LukkCcyr0R8opVL5IkoZCVi18w1G3yOubQ7fLKE4Bz6Y0sLeWdHsw1Eu93RegbG66RDj2SM4OFUfivilU98mhYQOJ8MEqWzmVjVDh9UAsWphBN1LhOCxlwUg5aYzfCwNAyH8PJFkavk5HVJGyGyKLtw2Id2G4ZgGUiLifayIzowGEDnsvMaadkilxBo6PXgZfwaA9Gn6QVtB21jqikvtDJeaPUC@S9KqTcQMGzoiIlm5c5LgSyXMQSCwBShEEWGHCwc3E7AzDEchHAPnMIBCBj4ttq9tiUQ@xFE67a7220/8m0/WrPd9W3/Hm2zcT6VKgG8rDLgUl7PBguZiBBmWYigGh7nUm4L7IELzBoO2k@gTcdwTh9taIc2Mja8j3qUZbLYdIcA/jXujn6lO0Flgfl@s8XTvp/xh2sZH/kZf2hPs25@/BvMj@82f/gbzB/eYT6jyj8zidviYQ89OIbJdWbE657gPrT9I9mDs43HkVFbud3jbsPj3haPV3WPu2sesdqpa2XOW039dzXlP1gf3Nn@mM6zBXZl6mQ6TnM5aPGX7TOmjWI1Yb1VDG4sb6ixPPCIZSeBkiagBw/wvyREdfnu3fJGwZU9fwdhLSJDM5U9wtRYdUMm6dCXMyV5t1xGtXRWiy5rRnfWUBh/rsLh5yrc9xQM0nwNpjRVrj5TxcJo1JDJLFwSvO2UpPHiIhdZJvFeo7Eo6Yt8BXKpdKFxmJoQEa@3QSueCa3hWSYT69xNIgWOYSX9J7QPqL6DdyKdc1Y298ATCb3hprToLupthkv@iG93uXRTDnrip8pmUIWJgcDfGf61ANDK2HMtKMxsu2vHH61tFHdohh58HOBiQDNeaKIiFo0@@OixKP0/FjjIFivOeJzO52kCehHJJXYTrXEoATlTc5UIGlAw9Vo2ZgUu5aB8cpkpH1lloXE8XqJ9LDCahoISjUvo023VhYBleIEzAo14uJNXyw5Zwk@snCVhlUzg2sxtKbaY/EJpak6GwVvKQNHIjubOBm4GfgCjEY7KGX1hpxvxQGag7M/sKc3tmlvXIlFnCwkJXKjiFJJeMk66mAFaPUsoCxgC/gXB45SXYMdidAP2r5oxq3Q4/Yzbt1yycPCKbPRLzZksgM2OKCJHxemQaD3@xM5AX12zuM9Ixn0IUFgsMF/MCpXNcEPHMBm0JupcTTAfE2TZzEYUE9/uE6Ce6Wtn6QXO3KhKeNR6MaeWnxEvy9VchoMWSzw7fk5LUkCrCC1rNaLgHtu4nOuIXGPu3Tqr@fwKEH4CmSeqIMd0AJHQsp8BviZEGI3eForS37CWAG2TSojbxfU9eCVcUnkSoG7HK5t2cBHXthOxnMnSGeTEz3mOIKqmjGEP7CKIeiAIuRE@5KHZzFGCp/QXGVO18FsNfPznf27eQZHSww5XWS6ptmRS0FaKBZ4SvvVlQlECInp5oisLL7Gf@UKJ2O6Ht8nHf7z98sPbCRzi4st9/kLaNdF2DEYjrAd0KmLzMoGtNE9FfEpuWAWBPSVjKolzicnVw8o0XV83727e79PHwc27j//@b7B7834a0npayl3fKhdM6R4IjfSE@j0J/GuPeA8rWRa6edf68PbrdIF9PYOpKd9aRVDDICtVVYhZWVnIVx7HkBSdDSeSA5mG1DKuoEnGfwJnaGIc1Y2AgxNac3Ka@q1FDmyIxQYkmgHV7XEEiueR0uy6e9NSFOHtsSl2V0hcq0ZzeLWuVGG6GZfqgOhsjG1jhCztx9jYua9JISkn3YxVMYK7aC7EP88MdbcSdUuUmPoOSpxZkR4svQbIOLEcK4nHaIpPco1IKhFJ/1we8v@oDrmlNKSN0eL65ynHahnXHsMDviTcT0uKvAvi0kc4da49exDEwhe9VytqQPUzmsJqGzibNUItpXH0vhNBjWajD9X00YSqB1IfnbSIaDFdw@kaQh02o83wrAVKUttC7dwV6ya0uqCDqiEQVqv4qbV31oArt@HWYUJuQ61hGDFpIfsDTXlmxgWxA9EOxPDxl1/osoAgwREFB164lHkaGhCLm/fcyvFeuHnPYw9enHyLWsbIMHrMcEKVVow3jf/ec26WhEo3mNzzEUrwibe2YEJ14@CmFSjqhx/43R5v5rUa3gABWdOo5@82xAg8G2u/y1WE2ktabW6CTa3rmtb11tZp9SISt86oF5Hearu3DZrXdc3rWzSN7gEEsdGpQr28VQsPYGlwyaHhIV0S0nl/TLumoe1yy93SMILaK6NYGUHtlXFwtxEXwtIz4kJYOiMhjVT0qzm/cDzDl2mzsj954viHNRV4b5P4EfJvnMWLIv8@QZ77eeIrZrrfRqHdDj99@h8 "Haskell – Try It Online")
[Answer]
# 270
```
E1                                                                              { Exist 1, defined when Any k introduced }
Ec1 Ec2 Ec3 Ec4 Ec5 Ak k*1=k & c3>1 & ( En0 An n<n0 |                           { for large enough n, |(c1-c4)e+c3(4-pi)/8+(c2-c5)|<1/k }
Ex Ep Ew Emult At (Eb ((b>1 & Eh b*h=t) &! Eh h*p=b)) |                         { x read in base-p, then each digit in base-w. t as a digit }
Ee1 Ee2 Ehigher Elower e2<p & lower<t & ((higher*p+e1)*p+e2)*t+lower=x &        { last digit e1, this digit e2 }
    { Can infer that e2=w+1 | e1<=e2 & u1<=u2 & i1<=i2 & s1<=s2 & t1<=t2, so some conditions omitted }
Ei1 Es1 Et1 Eu1 (((u1*w)+i1)*w+t1)*w+s1=e1 &                                    { (u,i,t,s) }
Ei2 Es2 Et2 Eu2 i2<w & s2<w & t2<w & (((u2*w)+i2)*w+t2)*w+s2=e2 &               { e2=1+w is initial state u=i=0, s=t=1 }
(e2=w+1 | e1=e2 | i2=i1+1+1 & s2=s1*(n+1) & t2=t1*n &                           { i=2n, s=(n+1)^n, mult=t=n^n, s/mult=e }
Eg1 Eg2 g1+1=(i2+i2)*(i2+i2) & g1*u1+mult=g1*u2+g2 & g2<g1) &                   { u/mult=sum[j=4,8,...,4n]1/(j*j-1)=(4-pi)/8. mult=g1*(u2-u1)+g2 }
(t>1 | i2=n+n & t2=mult & Ediff Ediff2                                          { check at an end t=1 }
c1*s2+c2*mult+c3*u2+diff=c4*s2+c5*mult+diff2 & k*(diff+diff2)<mult))            { |diff-diff2|<=diff+diff2<mult/k, so ...<1/k }
```
`a|b&c` is `a|(b&c)` since I think removing these parentheses makes it look better, anyway they're free. 
Used JavaScript `"(expr)".replace(/\{.*?\}/g,'').match(/[a-z0-9]+|[^a-z0-9\s\(\)]/g)` to count tokens.
]