Écrivez une déclaration mathématique en utilisant les symboles:

• There exists at least one non-negative integer(écrit comme E, quantificateur existentiel)
• All non-negative integers(écrit comme A, quantificateur universel)
• + (une addition)
• * (multiplication)
• = (égalité)
• >, <(opérateurs de comparaison)
• &(et), |(ou), !(non)
• (, )(pour le regroupement)
• noms de variables

ce qui équivaut à la déclaration

Il existe un nombre rationnel a, tel que π + e * a est rationnel.

(bien sûr, est la constante mathématique égale à la circonférence divisée par le diamètre d'un cercle, et est le nombre d'Euler )$\pi =3.1415...$$e=2.7182...$

Vous devez prouver que votre déclaration est en effet équivalente à la déclaration ci-dessus.

De toute évidence, la façon la plus «courte» de procéder consiste à prouver que la déclaration est vraie ou fausse, puis à répondre par une déclaration triviale vraie ou fausse, car toutes les déclarations vraies sont équivalentes les unes aux autres, comme toutes les déclarations fausses.

Cependant, la valeur de vérité de l'énoncé donné est un problème non résolu en mathématiques : nous ne savons même pas si est irrationnel! Par conséquent, à moins d'une recherche mathématique révolutionnaire, le défi consiste à trouver une déclaration équivalente «simple», à prouver son équivalence et à la décrire aussi brièvement que possible.$\pi+e$

Notation

E A + * = > < & |et !chacun ajoute 1 au score. (et )n'ajoutez rien au score. Chaque nom de variable ajoute 1 au score.

Par exemple, E x (A ba x+ba>x*(x+ba))score 13 ( E x A ba x + ba > x * x + ba)

Le score le plus bas l'emporte.

Remarque:

_{Avertissement: Cette note n'a pas été écrite par le PO.}

• Ce n'est pas un défi de code-golf . Il n'est pas nécessaire que les réponses contiennent du code.
• Ceci est similaire, mais pas une preuve de golf défi, car vous devez écrire une déclaration et prouver équivalente à une autre déclaration.
• Vous êtes autorisé à soumettre une Ax x=xdéclaration trivialement vraie (par exemple, pour tous les x, x = x ) ou une déclaration trivialement fausse (par exemple, pour tous les x, x> x Ax x>x) si vous pouvez prouver que la déclaration ci-dessus est vraie / fausse.
• Vous êtes autorisé à utiliser des symboles supplémentaires (similaires au lemme dans le golf d'épreuve), mais le score serait compté de la même manière que si vous ne les utilisiez pas.
  Par exemple, si vous définissez a => bcomme signifiant (!a) | b, chaque fois que vous utilisez =>dans votre preuve, votre score augmente de 2.

• Étant donné que les constantes ne sont pas répertoriées dans les symboles autorisés, vous ne devez pas les utiliser.
  Par exemple: l'instruction 1 > 0peut être écrite sous la forme

  
  Forall zero: ( zero + zero = zero ) =>
  Forall one: ( Forall x: x * one = x ) =>
  one > zero
  

  au score de 23. (rappelez-vous que cela =>coûte 2 par utilisation).

Conseils

• Pour utiliser des constantes naturelles, vous pouvez le faire E0, 0+0=0 & E1, At 1*t=t &(vous n'avez donc pas besoin de =>ce qui est plus étendu); pour les nombres supérieurs à 1, ajoutez simplement quelques 1

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))))))))))))))))))))))))))

Comment ça fonctionne

Tout d'abord, multipliez par les dénominateurs communs supposés de a et (π + e · a) pour réécrire la condition comme: il existe a, b, c ∈ ℕ (pas tous zéro) avec a · π + b · e = c ou a · π - b · e = c ou −a · π + b · e = c. Trois cas sont nécessaires pour traiter les problèmes de signalisation.

Ensuite, nous devrons réécrire ceci pour parler de π et e via des approximations rationnelles: pour toutes les approximations rationnelles π₀ <π <π₁ et e₀ <e <e₁, nous avons un · π₀ + b · e₀ <c <a · π₁ + b · e₁ ou a · π₀ - b · e₁ <c <a · π₁ + b · e₀ ou −a · π₁ + b · e₀ <c <−a · π₀ + b · e₁. (Notez que nous obtenons maintenant la condition «pas tout zéro» gratuitement.)

Maintenant pour la partie difficile. Comment obtenir ces approximations rationnelles? Nous voulons utiliser des formules comme

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} ,

mais il n'y a aucun moyen évident d'écrire les définitions itératives de ces produits. Nous avons donc construit un peu de machinerie que j'ai décrite pour la première fois dans ce post de Quora . Définir:

divise (d, a): = ∃b, a = d · b,

powerOfPrime (a, p): = ∀b, ((b> 1 et divise (b, a)) ⇒ divise (p, b)),

qui est satisfaite si a = 1, ou p = 1, ou p est premier et a en est une puissance. alors

isDigit (a, s, p): = a <p et ∃b, (powerOfPrime (b, p) et ∃qr, (r <b et s = (p · q + a) · b + r))

est satisfaite si a = 0, ou a est un chiffre du nombre p de base s. Cela nous permet de représenter n'importe quel ensemble fini en utilisant les chiffres d'un certain nombre de base-p. Maintenant, nous pouvons traduire des calculs itératifs en écrivant, en gros, il existe un ensemble d'états intermédiaires tels que l'état final est dans l'ensemble, et chaque état dans l'ensemble est soit l'état initial ou suit en une étape d'un autre état dans le ensemble.

Les détails sont dans le code ci-dessous.

Génération de code dans Haskell

{-# 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 "")

Essayez-le en ligne!

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&cest a|(b&c)parce que je pense que la suppression de ces parenthèses donne une meilleure apparence, de toute façon elles sont gratuites.

JavaScript utilisé "(expr)".replace(/\{.*?\}/g,'').match(/[a-z0-9]+|[^a-z0-9\s\(\)]/g)pour compter les jetons.