AchillesNumbers

The Achilles numbers $72, 108, 200, 288, …$ -- powerful but not a perfect power -- as a lazy indexed collection.

OEISA052486

AchillesNumbersthe powerful

n > 1

that aren't of the form

a^k

(

a, k \ge 2

), an infinite indexed collection.

Domain: Collections

Details

A lazy indexed collection: $Count(AchillesNumbers) = +\infty$ , and $At$ unranks the $k$ -th by scanning forward, testing [[PowerfulNumbers|powerfulness]] and then [[PerfectPowerNumbers|non-perfect-power]]ness.
OEIS A052486. $72 = 2^3 \cdot 3^2$ is the smallest: every prime factor's exponent is $\ge 2$ (powerful), but no single base and exponent produce it (not a perfect power).
Membership goes through Element: $Element(72, AchillesNumbers)$ is true, $Element(64, AchillesNumbers)$ is false ( $64 = 2^6$ , a perfect power).

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 >
                                                                              1 &&
                                                                              Fold(
                                                                                    Function(pw_f ||
                                                                                             pw_b ^ 3 <=
                                                                                             sn_k &&
                                                                                             sn_k %
                                                                                             pw_b ^ 3 ==
                                                                                             0 &&
                                                                                             Round(Sqrt(sn_k /
                                                                                                        pw_b ^ 3)) *
                                                                                             Round(Sqrt(sn_k /
                                                                                                        pw_b ^ 3)) ==
                                                                                             sn_k /
                                                                                             pw_b ^ 3, pw_f, pw_b),
                                                                                    False,
                                                                                    Range(1, Floor(sn_k ^
                                                                                                   (1 / 3)) +
                                                                                             2, 1),
                                                                                  ) &&
                                                                              !(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,
                    8 * Apply(
                               (pb_n: integer) => 11 if pb_n < 6 else Floor(pb_n *
                                                                            (Ln(pb_n) +
                                                                             Ln(Ln(pb_n)))) +
                                                                      1,
                               _r + 1 + 1,
                             ) ^ 2,
                    1,
                  ),
           ),
     )

rank(_x)

Fold(
      Function(sn_c + 1 if sn_k > 1 && Fold(
                                             Function(pw_f || pw_b ^ 3 <= sn_k &&
                                                              sn_k % pw_b ^ 3 ==
                                                              0 && Round(Sqrt(sn_k /
                                                                             pw_b ^
                                                                             3)) *
                                                                  Round(Sqrt(sn_k /
                                                                             pw_b ^
                                                                             3)) == sn_k / pw_b ^
                                                                             3, pw_f, pw_b),
                                             False,
                                             Range(
                                                    1,
                                                    Floor(sn_k ^ (1 / 3)) + 2,
                                                    1,
                                                  ),
                                           ) && !(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 > 1 && Fold(
                         Function(pw_f || pw_b ^ 3 <= _x &&
                                          _x % pw_b ^ 3 == 0 && Round(Sqrt(_x /
                                                                           pw_b ^
                                                                           3)) *
                                                                Round(Sqrt(_x /
                                                                           pw_b ^
                                                                           3)) == _x / pw_b ^
                                                                         3, pw_f, pw_b),
                         False,
                         Range(1, Floor(_x ^ (1 / 3)) + 2, 1),
                       ) && !(_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 > 1 && Fold(
                Function(pw_f || pw_b ^ 3 <= _x && _x % pw_b ^ 3 == 0 && Round(Sqrt(_x /
                                                                                    pw_b ^ 3)) *
                                                                         Round(Sqrt(_x /
                                                                                    pw_b ^ 3)) == _x /
                                                                             pw_b ^
                                                                             3, pw_f, pw_b),
                False,
                Range(1, Floor(_x ^ (1 / 3)) + 2, 1),
              ) && !(_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

AchillesNumbers ​

Definition

Enumeration

Examples

AchillesNumbers