A316532 Leading least prime signatures, ordered by the underlying partitions, as in A063008.

1, 6, 30, 36, 210, 180, 2310, 216, 900, 1260, 30030, 1080, 6300, 13860, 510510, 1296, 5400, 7560, 44100, 69300, 180180, 9699690, 6480, 27000, 37800, 83160, 485100, 900900, 3063060, 223092870, 7776, 32400, 45360, 189000, 264600, 415800, 1081080, 5336100

Offset: 0

Author

Jack W Grahl, Jul 06 2018

Keywords

• nonn
• easy

Comments

The sequence A063008 gives the least number with each prime signature, ordered by the underlying partition. This sequence is a subsequence which only includes those prime signatures M for which M/2 is not a prime signature, the so-called 'leading' least prime signatures.

This sequence is therefore constructed by taking the partitions first in increasing order of their sum, then in decreasing order of the first term, then decreasing order of the second term, etc. We drop all partitions, except the empty partition, where the first term and the second term are different. Then we map (m1, m2, m3, ..., mk) to 2^m1 * 3^m2 * ... * pk^mk to give the terms of this sequence.

The sequence A062515 had a description which suggested that it had been confused with this sequence. They are the same leading least prime signatures, but in a different order, given by a different construction using integer partitions.

Examples

			The first few partitions are [], [1,1], [1,1,1], [2,2], [1,1,1,1]. So the first few terms are 1, 2 * 3 = 6, 2 * 3 * 5 = 30, 2^2 * 3^2 = 36, 2 * 3 * 5 * 7 = 210.
		

Crossrefs

Subsequence of A063008. A re-ordering of A062515, also of A056153. Cf A025487.

Programs

Haskell

primes :: [Integer]
primes = 2 : 3 : filter (\a -> all (not . divides a) (takeWhile (\x -> x <= a `div` 2) primes)) [4..]
divides :: Integer -> Integer -> Bool
divides a b = a `mod` b == 0
partitions :: [[Integer]]
partitions = concat $ map (partitions_of_n) [0..]
partitions_of_n :: Integer -> [[Integer]]
partitions_of_n n = partitions_at_most n n
partitions_at_most :: Integer -> Integer -> [[Integer]]
partitions_at_most _ 0 = [[]]
partitions_at_most 0 _ = []
partitions_at_most m n = concat $ map (\k -> map ([k] ++) (partitions_at_most k (n-k))) ( reverse [1..(min m n)])
prime_signature :: [Integer] -> Integer
prime_signature p = product $ zipWith (^) primes p
seq :: [Integer]
seq = map prime_signature $ filter compare_first_second partitions
    where
  compare_first_second p
        | length p == 0 = True
        | length p == 1 = False
        | otherwise = p!!0 == p!!1