In Pinochle, what is the probability of a thousand aces and a double run in one hand?
TLDR: This will happen roughly once every 1.7 million hands.
Rules Background
Double-deck Pinochle is a four player game using a deck of 80 cards (four lots of ATKQJ in each of ♣♦♥♠) (cf. Wikipedia and this rules page).
A double run is two sets ATKQJ in whichever suit is declared trumps.  Trumps is decided by a bidding mechanism, but for this answer we'll assume that the bidding was won by the player in question, and trumps were chosen to match the hand.  Consequently we're interested in the chance of being dealt two sets of ATKQJ both in the same suit.
&quot;A thousand aces&quot; is a term from standard (single-deck) Pinochle, and refers to two &quot;arounds&quot; of aces (i.e. A♣ A♦ A♥ A♠ x 2).  In standard Pinochle this is all of the aces in the deck and is worth 1000 points.  In double-deck Pinochle this is only half the aces, so is much more common and is only worth 100 points.
Melds in Pinochle are allowed to reuse cards (as long as they are different types of melds), and so the aces for the runs can be reused in the arounds.  Consequently the required cards for the hand are A♣ A♦ A♥ A♠ A♣ A♦ A♥ A♠ Tx Kx Qx Jx Tx Kx Qx Jx for some suit x, which leaves four cards unspecified.
Simulation
The calculation of this seemed quite involved (although see L. Scott Johnson's full calculation), so I wrote a Python script to estimate the probability:
import random
from multiprocessing.dummy import Pool as ThreadPool 

suits='CDHS'
ranks='ATKQJ'
cards = [r+s for s in suits for r in ranks] * 4

def simulate(_):
    matches = 0
    for i in range(innerLoops):
        hand = random.sample(cards, 20)
        if hand.count('AC') &gt;= 2 and hand.count('AD') &gt;= 2 and hand.count('AH') &gt;= 2 and hand.count('AS') &gt;= 2:
            for s in suits:
                if hand.count('T'+s) &gt;= 2 and hand.count('K'+s) &gt;= 2 and hand.count('Q'+s) &gt;= 2 and hand.count('J'+s) &gt;= 2:
                    matches += 1
                    break
    return matches

poolSize = 8
pool = ThreadPool(poolSize)
loops = 100000000
innerLoops = loops / poolSize
for j in range(5):
    results = pool.map(simulate, range(poolSize))
    print('{} / {}'.format(sum(results), loops))

When I ran this the output was:
58 / 100000000
65 / 100000000
61 / 100000000
57 / 100000000
54 / 100000000

Combining these results gives an average of about 295 times in five hundred million hands, or 1/1694915.  This result supports the full calculation by L. Scott Johnson.