PerfectPowerNumbers

The perfect powers $4, 8, 9, 16, 25, …$ -- integers $a^k$ with $a \ge 2, k \ge 2$ -- as a lazy indexed collection.

OEISA001597↗

PerfectPowerNumbersthe $a^k$ for integers $a \ge 2, k \ge 2$, an infinite indexed collection.

Domain: Collections

Details

• A lazy indexed collection: $Count(PerfectPowerNumbers) = +\infty$, and $At$ unranks the $k$-th by scanning forward, testing each candidate by binary search over exponents.
• OEIS A075109 -- the $a \ge 2$ convention excludes $1$, unlike A001597's $m > 0$.
• Membership goes through Element: $Element(16, PerfectPowerNumbers)$ is true ($16 = 2^4 = 4^2$), $Element(1, PerfectPowerNumbers)$ is false under this convention (needs $a \ge 2$).

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 sn_k >=
                                                                              4 &&
                                                                              Fold(
                                                                                    Function(pp_f ||
                                                                                             Round(sn_k ^
                                                                                                   (1 / pp_e)) >=
                                                                                             2 &&
                                                                                             Round(sn_k ^
                                                                                                   (1 / pp_e)) ^
                                                                                             pp_e ==
                                                                                             sn_k, pp_f, pp_e),
                                                                                    False,
                                                                                    Range(2, Floor(Log(sn_k, 2)) +
                                                                                             1, 1),
                                                                                  ) else sn_s,
                      sn_s,
                      sn_k,
                    ), 0, Range(1, (_r + 1 + 1) ^ 2, 1)),
     )

rank(_x)

Fold(
      Function(sn_c + 1 if sn_k >= 4 && Fold(
                                              Function(
                                                        pp_f || Round(sn_k ^ (1 /
                                                                              pp_e)) >=
                                                                2 && Round(sn_k ^
                                                                          (1 /
                                                                           pp_e)) ^
                                                                    pp_e == sn_k,
                                                        pp_f,
                                                        pp_e,
                                                      ),
                                              False,
                                              Range(
                                                     2,
                                                     Floor(Log(sn_k, 2)) + 1,
                                                     1,
                                                   ),
                                            ) else sn_c, sn_c, sn_k),
      0,
      Range(1, _x - 1, 1),
    ) if (_x >= 4 && Fold(Function(
                                   pp_f || Round(_x ^ (1 / pp_e)) >= 2 && Round(_x ^
                                                                                (1 / pp_e)) ^
                                                                          pp_e == _x,
                                   pp_f,
                                   pp_e,
                                 ), False, Range(2, Floor(Log(_x, 2)) + 1, 1)) if _x >= 1 else False) else -1

valid(_x)

_x >= 4 && Fold(
                 Function(
                           pp_f || Round(_x ^ (1 / pp_e)) >= 2 && Round(_x ^ (1 /
                                                                              pp_e)) ^
                                                                  pp_e == _x,
                           pp_f,
                           pp_e,
                         ),
                 False,
                 Range(2, Floor(Log(_x, 2)) + 1, 1),
               ) if _x >= 1 else False

Enumeration

Examples

1 more kept as data, checked against the oracles

About

Examples	1
Crosswalk	OEIS

See also: Count, At, Element, PowerfulNumbers, SquareNumbers