What are the odds in Scrabble of not being able to make a legal move on opening turn
(NOTE : Final revision of my original answer)
The odds of the first tileset not having a single valid word is exactly 91,595,416 / 16,007,560,800 or .5722%, with it occuring once every 174.76378 games.  This value is calculated by using the dictionary found in this answer, but can be adapted for any other dictionary.

This was brute-forced via python.  Code will be available at the end of the answer.

We start by noticing that any tileset that contains at least one blank tile can play a valid word.  The only letter that does not form a two letter word is the letter &quot;V&quot;, and there are only 2 &quot;V&quot; tiles in a scrabble game.  Therefore, any tileset with one blank can form a valid word, because (?VV....) must contain 4 more letters, one of which will combine with the &quot;?&quot; to form a valid word.
We also discovered, after the fact, that all possible tilesets that contain the letter &quot;O&quot; are also, in fact, valid.  The only 6 tile tileset that contains &quot;O&quot; and cannot form a word is &quot;OCCVVQ&quot; and any other letter will form a word. &quot;A&quot; is the only other letter that doesn't form a two letter word with &quot;O&quot; but &quot;AVO&quot; and &quot;OCA&quot; are both valid words, and you can't include more than one O or one A or else you can form &quot;AA&quot; or &quot;OO&quot;.
These observations remove 53.32% of all possible tilesets, and allows us to perform the rest of our calculations using a 90-tile scrabble set that has no blanks and no Os in it.
We then remove from the dictionary all words that satisfy one of the following criteria

Word is longer than 7 letters long (can't spell an 8 letter word on the first turn)
A subset of the tiles required to form that word can also make another word (we're just looking to see if we can form a valid word, therefore there is no reason to check to see if a tileset can form the word &quot;AND&quot; when &quot;AN&quot; is a perfectly valid word as well)
Word requires at least one blank tile to solve (any tileset with a blank is valid, therefore no reason to examine these words).  These are the words FUFF (3rd F), JUJU (2nd J), KECK and KUKU (2nd K), SYZYGY (3rd Y), ZIZ, ZUZ, and ZZZ (2nd/3rd Z).
Word requires an O to solve.  All O tilesets are valid and we've removed them from the bag.

By applying these three rules, we can reduce the scrabble dictionary down to 149 words out of the original 280k~.

AA
AB
AD
AE
AG
AH
AI
AL
AM
AN
AR
AS
AT
AW
AX
AY
BE
BI
BRR
BUB
BUD
BULK
BULL
BY
CH
CIRRI
CIVIC
CLY
CRY
CUB
CUD
CUE
CUFF
CULL
CUZ
CWM
DE
DI
DRY
DUD
EE
EF
EGG
EH
EL
EM
EN
ER
ES
ET
EUK
EW
EX
FA
FLU
FUB
FUCK
FUD
FY
GHYLL
GI
GRR
GU
GYP
HI
HM
HYP
ICE
ICY
IF
IN
IS
IT
IVY
IWI
JA
JEU
JIZ
JUD
JUKU
KA
KEG
KI
KUDU
KUZU
KY
LI
LUCK
LUD
LULL
LUV
LUZ
MI
MM
MU
MY
NTH
NU
NY
PA
PE
PFFT
PHT
PI
PLY
PRY
PWN
PYX
QI
QUA
RHY
RIZ
SH
SLY
SPY
ST
SWY
THY
TRY
TWP
TYG
TYPP
TYPY
UH
ULU
UP
UR
US
UT
UVA
VAC
VAV
VEG
VIE
VLY
WHY
WIZ
WRY
WUD
WULL
WUZ
XI
XU
XYLYL
YE
YIRR
YU
ZA
ZE
ZO


At this point, we are going to brute force the number of invalid tilesets to get the numerator.  We do this by examining tilesets that are in alphabetical order, but do not care if it's unique.  For example, we will examine (A1A2BCDEF) and (A1A3BCDEF) but not (A2A1BCDEF), where A1, A2, and A3 refer to distinct A tiles in the bag.
The first tileset examined is (A1A2A3A4A5A6A7), followed by (A1A2A3A4A5A6A8), then (A1A2A3A4A5A6A9), and then finally (A1A2A3A4A5A6B1).  We continue down that path in the way that only a computer can do to determine every single alphabetized combination.
(Note that in the final version of my code, we change the definition of &quot;alphabetical order&quot; in order to get a speed improvement, but the final solution is the same.  Also, for speed reasons, we would never actually examine (AA.....) because &quot;AA&quot; is a valid word, so we would skip all tilesets of the form (AA.....))
After running through all the tilesets, we end with a final count of 91,595,416 tilesets.  This is our numerator, and the denominator is very easily calculated

100! / ((100-7)! * 7!) = 16,007,560,800

This is the calculation for finding the number of combinations possible, without replacement, and not caring about order (which we don't because otherwise this problem would be an few orders of magnitude harder to brute force.

I'm going to be putting some interesting notes down here as I play around with the program.

There is exactly 1 distinct tileset that has an &quot;A&quot; in it and is still invalid.  This tileset is &quot;ACCUUUU&quot;.  The proof is left as an exercise for the reader.
Of the 91,595,416 invalid tilesets found, there are only 22,308 that contain exclusively vowels.  This is a much smaller number than I originally thought, but from reading the valid word list it makes sense.  As previously discussed, A only has the invalid tileset &quot;ACCUUUU&quot; and all O tilesets are valid.  Combined with the fact that &quot;EE&quot; is also a valid word, all vowel only tilesets without a valid word have to be of the form &quot;EI...U...&quot; or &quot;I...U...&quot;.
Tilesets with a mix of vowels and consanants takes up a slightly larger amount of invalid tilesets, at 106,201 possible combinations.
Shocking no one, the vast majority of invalid tilesets are consonant only tilesets.  Of the 91,595,416 invalid tilesets, 91,466,907 of them are consonant only sets, which makes up 99.86% of all invalid tilesets.
Once the dictionary is purged of words that contains the letters [AEIOUY] there are only 13 words that can still be formed.  These 13 words can be, in turn, checked by looking at the letters [HPMRS].  This means that any tileset that contains nothing but the letters [BCDFGJKLNQTVWXZ] is invalid.  This comprises 15 of the 26 letters and 38 of the tiles in the bag.  Tilesets that contain only these letters comprise roughly 12% of all invalid tilesets.


Code, if anyone wants to run it for themselves (WARNING: slow, running on a beefy computer it still about a half hour to spit out an answer)
words = []

words_in_dictionary = 0
words_short_enough = 0

def is_all_c(arr1):
   for c in arr1:
      if c in ['A','E','I','O','U']:
         return False
   return True
   
def is_all_v(arr1):
   for v in arr1:
      if v in ['B','C','D','F','G','H','J','K','L','M','N','P','Q','R','S','T','V','W','X','Y','Z']:
         return False
   return True

#basic function to check if an array, arr1, is fully within a second array, arr2
def i_in_j(arr1, arr2):
   for a in arr1:
      if a in arr2:
         arr2.remove(a)
      else:
         return False
   return True

#basic function to check to see if word can be made from the tileset passed in
def is_valid_tileset(tileset):
   for word in words:
      if i_in_j(word[&quot;sorted&quot;][:], tileset[:]):
         return word[&quot;base&quot;]
   return None
   
# we have a big dictionary, 270k-ish words long, we need to load it
print(&quot;loading dictionary&quot;)
with open(&quot;dictionary.txt&quot;, &quot;r&quot;) as dictfile:
   for line in dictfile:
      words_in_dictionary = words_in_dictionary + 1
      base_word = line.strip()
      
      #we are going to parse out the words longer than 7 letters now because it's quicker
      #we are also going to get rid of words with &quot;O&quot; in it
      if len(base_word) &lt;= 7:
         if not &quot;O&quot; in base_word:
            words_short_enough = words_short_enough + 1
            word = {&quot;base&quot;: base_word, &quot;sorted&quot;: sorted(base_word)}
            words.append(word)
         
      
   
print(&quot;total words in dictionary is &quot; + str(words_in_dictionary))   
print(&quot;words 7 letters or shorter is &quot; + str(words_short_enough))

# now we need to build our dictionary of unique words
# any word where a subset of the letters in that word can be used to build another word will be discarded
# for example, &quot;AND&quot; will be discarded because we can make &quot;AN&quot; out of that word
i = 0
while i &lt; len(words):
   temp_sorted_working_word = words[i][&quot;sorted&quot;]
   
   j = 0
   while j &lt; len(words):
      if i == j:
         j = j + 1
         continue
         
      if i_in_j(words[i][&quot;sorted&quot;][:], words[j][&quot;sorted&quot;][:]):
         del words[j]
         if i &gt; j:
            i = i - 1
            j = j - 1
         elif j &gt; i:
            j = j - 1
      
      j = j + 1
   i = i + 1
   
# there are also 8 words from this list that cannot be built without blanks, and we know that any tileset
# with at least one blank is valid
i = 0
while i &lt; len(words):
   if words[i][&quot;base&quot;] in [&quot;FUFF&quot;, &quot;JUJU&quot;, &quot;KECK&quot;, &quot;KUKU&quot;, &quot;SYZYGY&quot;, &quot;ZIZ&quot;, &quot;ZUZ&quot;, &quot;ZZZ&quot;]:
      del words[i]
   else:
      i = i + 1

print(&quot;unique minimilized word combinations is &quot; + str(len(words)))

# this is an array of all tiles in scrabble, minus the blanks (since we don't care about them)
# because we're pruning words from the dictionary, we've rearranged the letters to try and remove as many
# words as possible as quickly as possible, to make lookups run faster, this means that the vowels and
# R,S,T,L,N have been moved up the list, it doesn't really impact anything, as alphabetical order is arbitary
# and nothing from this point forward depends on us having a sorted list 
letters = ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'Y', 'Y', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'I', 'U', 'U', 'U', 'U', 'H', 'H', 'P', 'P', 'M', 'M', 'R', 'R', 'R', 'R', 'R', 'R', 'T', 'T', 'T', 'T', 'T', 'T', 'W', 'W', 'C', 'C', 'N', 'N', 'N', 'N', 'N', 'N', 'S', 'S', 'S', 'S', 'B', 'B', 'F', 'F', 'G', 'G', 'G', 'L', 'L', 'L', 'L', 'D', 'D', 'D', 'D', 'J', 'K', 'Q', 'V', 'V', 'X', 'Z']

invalid_tilesets = 0

for a in range(0, 84):
   # if we've finished using a letter in the tileset, we're gonna remove the words in the condensed dictionary
   # that utilize those letters, this is more of a speed thing than anything else because those dictionary lookups
   # are expensive
   if a &gt; 0 and letters[a-1] != letters[a]:
      i = 0
      while i &lt; len(words):
         if i_in_j([letters[a-1]], words[i][&quot;sorted&quot;]):
            del words[i]
         else:
            i = i + 1
   
   print(&quot;invalid_tilesets = &quot; + str(invalid_tilesets) + &quot; | new_first_letter = &quot; + letters[a] + &quot; | words in dictionary = &quot; + str(len(words)))
   
   for b in range(a+1, 85):
      if not is_valid_tileset([letters[a], letters[b]]):
         for c in range(b+1, 86):
            if not is_valid_tileset([letters[a], letters[b], letters[c]]):
               for d in range(c+1, 87):
                  if not is_valid_tileset([letters[a], letters[b], letters[c], letters[d]]):
                     for e in range(d+1, 88):
                        if not is_valid_tileset([letters[a], letters[b], letters[c], letters[d], letters[e]]):
                           for f in range(e+1, 89):
                              if not is_valid_tileset([letters[a], letters[b], letters[c], letters[d], letters[e], letters[f]]):
                                 for g in range(f+1, 90):
                                    if not is_valid_tileset([letters[a], letters[b], letters[c], letters[d], letters[e], letters[f], letters[g]]):
                                       invalid_tilesets += 1
                                       
                                       if invalid_tilesets % 10000 == 0:
                                          print(&quot;invalid_tilesets = &quot; + str(invalid_tilesets) + &quot; | &quot; + str([letters[a], letters[b], letters[c], letters[d], letters[e], letters[f], letters[g]]) + &quot; | &quot; + str([a,b,c,d,e,f,g]))
                                       
                                          
                                 
   
   
print(&quot;invalid_tilesets = &quot; + str(invalid_tilesets))