PrimePowerNumbers

The prime powers $2, 3, 4, 5, 7, 8, 9, 11, …$ : $p^k$ for a prime $p$ and $k \geq 1$ (excluding 1, which is $p^0$ ).

OEISA246655mathlib4IsPrimePow

PrimePowerNumbersthe

n = p^k

for a prime

p

and integer

k \geq 1

, an infinite indexed collection.

Domain: Collections

Details

A lazy indexed collection: $Count(PrimePowerNumbers) = +\infty$ (PrimeNumbers alone already is). OEIS A246655.
$At(PrimePowerNumbers, k)$ unranks by scanning forward, factoring each candidate -- $At(PrimePowerNumbers, 3) = 4$ ( $2^2$ ).
Membership goes through Element: $Element(9, PrimePowerNumbers)$ is true ( $3^2$ ), $Element(12, PrimePowerNumbers)$ is false ( $2^2 \times 3$ , two distinct primes).

Definition

Epsil, as the implementation runs it.

count()

PositiveInfinity

unrank(_r)

Apply(
       (sn_f: integer) => sn_f if sn_f > 0 else `NaN`,
       Fold(
             Function(sn_s if sn_s > 0 else (sn_k if sn_s + _r == 0 else sn_s -
                                                                         1) if Apply(
                                                                                     (fw_e: list<integer>) => fw_e[4] +
                                                                                                              (1 if fw_e[1] > 1 &&
                                                                                                                    !(fw_e[1] == fw_e[2] &&
                                                                                                                      fw_e[5] == 1) else 0) ==
                                                                                                              1,
                                                                                     Fold(
                                                                                           Function(fw_w if fw_w[2] * fw_w[2] >
                                                                                                            fw_w[1] else [
                                                                                                                    fw_w[1] / fw_w[2],
                                                                                                                    fw_w[2],
                                                                                                                    fw_w[3] + 1,
                                                                                                                    fw_w[4] +
                                                                                                                    (1 - fw_w[5]),
                                                                                                                    1,
                                                                                                                  ] if fw_w[1] % fw_w[2] ==
                                                                                                                      0 else [fw_w[1], fw_w[2] + 1, fw_w[3], fw_w[4], 0], fw_w, fw_i),
                                                                                           [sn_k, 2, 0, 0, 0],
                                                                                           Range(1, Floor(Sqrt(sn_k)) +
                                                                                                    Floor(Log(sn_k, 2)) +
                                                                                                    2, 1),
                                                                                         ),
                                                                                   ) else sn_s, sn_s, sn_k),
             0,
             Range(
                    1,
                    Apply(
                           (pb_n: integer) => 11 if pb_n < 6 else Floor(pb_n *
                                                                        (Ln(pb_n) +
                                                                         Ln(Ln(pb_n)))) + 1,
                           _r + 1,
                         ),
                    1,
                  ),
           ),
     )

rank(_x)

Fold(Function(sn_c + 1 if Apply(
                                 (fw_e: list<integer>) => fw_e[4] +
                                                          (1 if fw_e[1] > 1 &&
                                                                !(fw_e[1] ==
                                                                  fw_e[2] && fw_e[5] ==
                                                                      1) else 0) == 1,
                                 Fold(
                                       Function(fw_w if fw_w[2] * fw_w[2] >
                                                        fw_w[1] else [
                                                                fw_w[1] /
                                                                fw_w[2],
                                                                fw_w[2],
                                                                fw_w[3] + 1,
                                                                fw_w[4] + (1 -
                                                                           fw_w[5]),
                                                                1,
                                                              ] if fw_w[1] %
                                                                  fw_w[2] == 0 else [
                                                                               fw_w[1],
                                                                               fw_w[2] +
                                                                               1,
                                                                               fw_w[3],
                                                                               fw_w[4],
                                                                               0,
                                                                             ], fw_w, fw_i),
                                       [sn_k, 2, 0, 0, 0],
                                       Range(1, Floor(Sqrt(sn_k)) +
                                                Floor(Log(sn_k, 2)) + 2, 1),
                                     ),
                               ) else sn_c, sn_c, sn_k), 0, Range(1, _x - 1, 1)) if (Apply(
                                                                                           (fw_e: list<integer>) => fw_e[4] +
                                                                                                                    (1 if fw_e[1] > 1 &&
                                                                                                                          !(fw_e[1] == fw_e[2] &&
                                                                                                                            fw_e[5] == 1) else 0) ==
                                                                                                                    1,
                                                                                           Fold(
                                                                                                 Function(fw_w if fw_w[2] * fw_w[2] >
                                                                                                                  fw_w[1] else [
                                                                                                                          fw_w[1] / fw_w[2],
                                                                                                                          fw_w[2],
                                                                                                                          fw_w[3] + 1,
                                                                                                                          fw_w[4] +
                                                                                                                          (1 - fw_w[5]),
                                                                                                                          1,
                                                                                                                        ] if fw_w[1] % fw_w[2] ==
                                                                                                                            0 else [fw_w[1], fw_w[2] + 1, fw_w[3], fw_w[4], 0], fw_w, fw_i),
                                                                                                 [_x, 2, 0, 0, 0],
                                                                                                 Range(1, Floor(Sqrt(_x)) +
                                                                                                          Floor(Log(_x, 2)) +
                                                                                                          2, 1),
                                                                                               ),
                                                                                         ) if _x >= 1 else False) else -1

valid(_x)

Apply(
       (fw_e: list<integer>) => fw_e[4] + (1 if fw_e[1] > 1 && !(fw_e[1] ==
                                                                 fw_e[2] && fw_e[5] ==
                                                                     1) else 0) ==
                                1,
       Fold(
             Function(
                       fw_w if fw_w[2] * fw_w[2] > fw_w[1] else [
                                                                  fw_w[1] /
                                                                  fw_w[2],
                                                                  fw_w[2],
                                                                  fw_w[3] + 1,
                                                                  fw_w[4] + (1 -
                                                                             fw_w[5]),
                                                                  1,
                                                                ] if fw_w[1] %
                                                                    fw_w[2] == 0 else [
                                                                                 fw_w[1],
                                                                                 fw_w[2] + 1,
                                                                                 fw_w[3],
                                                                                 fw_w[4],
                                                                                 0,
                                                                               ],
                       fw_w,
                       fw_i,
                     ),
             [_x, 2, 0, 0, 0],
             Range(1, Floor(Sqrt(_x)) + Floor(Log(_x, 2)) + 2, 1),
           ),
     ) if _x >= 1 else False

Enumeration

Examples

1 more kept as data, checked against the oracles

About

Examples	1
Crosswalk	OEIS mathlib4

PrimePowerNumbers ​

Definition

Enumeration

Examples

PrimePowerNumbers