SemiprimeNumbers

The semiprimes $4, 6, 9, 10, 14, …$ : products of exactly two primes, with multiplicity ( $\Omega(n) = 2$ ).

OEISA001358

SemiprimeNumbersthe

n

with

\Omega(n) = 2

(two prime factors counted with multiplicity, so

4=2^2

counts), an infinite indexed collection.

Domain: Collections

Details

A lazy indexed collection: $Count(SemiprimeNumbers) = +\infty$ -- $2p$ is semiprime for every prime $p$ . OEIS A001358. Identical to KAlmostPrimes $(2)$ .
$At(SemiprimeNumbers, k)$ unranks by scanning forward, factoring each candidate -- $At(SemiprimeNumbers, 3) = 9$ ( $3^2$ ).
Membership goes through Element: $Element(9, SemiprimeNumbers)$ is true, $Element(8, SemiprimeNumbers)$ is false ( $2^3$ , $\Omega=3$ ).

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[3] +
                                                                                                              (1 if fw_e[1] > 1 else 0) ==
                                                                                                              2,
                                                                                     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,
                    2 * 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[3] +
                                                          (1 if fw_e[1] > 1 else 0) == 2,
                                 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[3] +
                                                                                                                    (1 if fw_e[1] > 1 else 0) ==
                                                                                                                    2,
                                                                                           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[3] + (1 if fw_e[1] > 1 else 0) == 2,
       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

SemiprimeNumbers ​

Definition

Enumeration

Examples

SemiprimeNumbers