What if the line collapsed

The unproven equality that, if proven, would rewire the entire economy in a week.

1. 01
   RSA is the most concrete bet on P ≠ NP. The encryption is one multiplication; the inverse is factoring. The Rust num-prime crate handles both halves and makes the asymmetry visible — primality test in microseconds, factoring of a 200-bit composite in minutes.

   use num_prime::nt_funcs::is_prime;
   use num_bigint::BigUint;
   
   fn rsa_modulus(p: &BigUint, q: &BigUint) -> BigUint {
       assert!(is_prime(p, None).probably());
       assert!(is_prime(q, None).probably());
       p * q
       // Recovering p, q from p*q alone is the bet.  No fast classical
       // algorithm is known.  The day one is found, every RSA key on the
       // internet is broken.
   }

2. 02
   is_prime does not return a plain bool — primality testing on huge integers is not always deterministic. The crate returns a three-valued Primality enum that distinguishes "proved prime," "proved composite," and "probably prime" (passed Miller-Rabin, the standard probabilistic test, with an error rate roughly 1 in 2⁶⁰ per witness). .probably() collapses both positive answers — proved-prime and probably-prime — into true, leaving only proved-composite as false. For cryptographic-sized numbers, "probably" is the right answer to act on; the false-positive rate is below the rate at which cosmic rays flip bits in your RAM.

   // is_prime() returns a tri-state, not just a bool:
   //
   //   Primality::Yes       → proved prime (deterministic test passed)
   //   Primality::Probably  → passed Miller-Rabin, no proof either way
   //   Primality::No        → proved composite (a witness was found)
   //
   // .probably() merges the two positive answers into true:
   let answer = is_prime(p, None);
   let acceptable: bool = answer.probably();
   //
   // Same as writing:
   let acceptable = match answer {
       Primality::Yes      => true,
       Primality::Probably => true,
       Primality::No       => false,
   };
   //
   // The 1-in-2⁶⁰ error rate sounds scary; in practice it is far
   // below the rate of hardware bit-flips from cosmic rays.  Every
   // piece of production crypto code in the world treats Probably
   // as Yes.