The answer is "maybe". 1000 inaudible whispers may still be inaudible; the question you probably meant to ask is "would the sound of 1000 people whispering at the same time be louder than the sound of 1 person whispering?"
The answer to that question is an emphatic "yes". How much louder will they be - and will that result in an audible / understandable message?
For this you need to understand the concept of interference and coherence. Two sources (of sound) are coherent if they produce the same waveform. In the real world, coherence is usually limited in time: if I have two tuning forks that are producing a nominal 440 Hz, one of them might produce a frequency of 440.1 Hz and after 5 seconds the two waveforms would have gone out of step by 180 degrees (this is the cause of "beats"). Any sound you make is comprised of many frequencies - see for example this question and associated answers - that together make up a recognizable phoneme (sound that a letter or group of letters makes). When two people "talk at the same time", they will be producing a phoneme, but not at the same frequency. Yet, when two people both say "A", our ears are pretty good at picking up the fact that they are saying "A" even when they are using a different fundamental frequency.
When two waveforms are incoherent (as is the case for multiple people speaking) we can add together the power of the individual voices, which goes as the square of the amplitude of individual voices. The actual amplitudes will sometimes add in phase (double the amplitude - four times the instantaneous power), at other times they will interfere destructively (zero amplitude, zero power). The time average is still the same as the sum of the power of the two sources.
The same is true for "many" sources. So if you have 1000 voices whispering, you can expect the amplitude on average to increase by about 30 x ($\sqrt{1000}$); if that amplitude is sufficient to exceed the threshold of hearing for you, you might be able to hear them; and if their voices are "quite similar" in pitch, you may be able to understand what they are saying. But the latter is not at all certain - the ability to distinguish phonemes becomes trickier when more frequencies are present. In fact, if everyone speaks "at their own pitch", the resulting sound will become like white noise and you will not understand what is being said.
UPDATE
I decided to do an experiment. I recorded myself saying a certain phrase 19 times, in approximately the same tempo and volume. I reduced the amplitude of the recording, and added some noise. This resulted in an "inaudible message".
Next, I cut the sound track into 19 segments that I aligned with the help of some signal processing (there was a distinct "th" sound at the start of the message). Adding these signals (remember - these are "different" recordings of the same message - a bit like having 19 different people trying to whisper the same thing at the same time), with the same amount of noise added, resulted in an audible messsage.
Finally, I messed around with the delays. Assuming that people would stand no closer than 1 m apart, you can assume that a large "chorus" of people will have some amount of relative delay in their whispering; I added a shift of "1 m delay" between each of the 19 signals before adding them up, and while the signal gets a little bit less crisp, it's still clearly audible.
Of course a group of 1000 people would be arranged to try to minimize this delay - if you arrange a large group of people in a series of concentric (semi) circles, the delay in arrival of the voices need not be much worse than in my example.
If you are interested in the Python code I used to do the image processing (note - there are a number of other experiments and plots in this code... feel free to play with it):
# read the whisper file
import scipy.io.wavfile as WVF
from scipy.signal import argrelextrema
import numpy as np
import matplotlib.pyplot as plt
import wave
# convert mp3 to wav:
# ffmpeg -i ~/Desktop/170826_0080.mp3 ~/Desktop/longwhisper.wav"
A = WVF.read('/Users/floris/Desktop/longwhisper.wav')
# attenuate the sound wave so I have some dynamic range for adding later
soundWave = 0.1*A[1].astype('float')
N = len(A[1])
timeAxis = np.arange(N).astype('float')/A[0]
# visualize sound wave
plt.figure()
plt.plot(timeAxis, soundWave)
plt.title('original sound wave')
plt.show()
# do some filtering
tt1 = np.linspace(-5,5,1000)
filt1 = np.exp(-tt1*tt1/2)
filt1 = filt1 / np.sum(filt1)
tt = np.linspace(-5,5,50000)
filt = np.exp(-tt*tt/2)
filt = filt / np.sum(filt)
baseline = np.convolve(soundWave, filt1, mode='same')
# high frequencies only:
hf = soundWave - baseline
plt.figure()
plt.plot(timeAxis, hf)
plt.plot(timeAxis, baseline, 'r')
plt.title('after subtracting baseline')
plt.show()
soundPower = hf*hf
soundPower = np.convolve(soundPower, filt, mode='same')
plt.figure()
plt.plot(timeAxis, soundPower)
plt.title('smoothed sound power')
plt.xlabel('time (s)')
plt.show()
# find the actual peaks
pks = argrelextrema(soundPower, np.greater)
pkVals = soundPower[pks[0]]
pkSort = np.argsort(pkVals)
# time points corresponding to the 40 largest peaks... this includes the "pops"
# at the start of each phrase
timePoints = np.sort(pks[0][pkSort[-40:]])
# look at the spacing between pops - we know it should be roughly 82000 samples
makeSense = np.diff(timePoints)
startPoints = []
currentTime = makeSense[0]
lastTime = currentTime
for ii in makeSense[1:]:
if abs(currentTime - 82000 - lastTime) < abs(currentTime + ii - 82000 - lastTime):
startPoints.append( currentTime)
lastTime = currentTime
currentTime += ii
# shift back a bit - we need to start just before the pop:
startPoints = np.array(startPoints)+timePoints[0]-8000
plt.figure()
for ii in range(len(startPoints)):
temp = soundPower[startPoints[ii]:startPoints[ii]+78000]
plt.plot(temp/np.max(temp)+0.1*ii)
plt.title('sound power after aligning')
plt.show()
# sum the blocks:
# high frequency filter on the noise - make it a bit more "pink":
tt2 = np.linspace(-5,5,20)
filt2= np.exp(-tt2*tt2/2)
filt2 = filt2 / np.sum(filt2)
def addNoise(waveIn, noiseAmp):
noise = np.convolve(np.random.random_integers(-noiseAmp, noiseAmp, size=np.shape(waveIn)), filt2, mode='same')
return waveIn + noise
def writeFile(block, fileName):
pv = block.astype(np.int16).tobytes()
sound = wave.open(fileName, 'w')
sound.setparams((1,2,44100, 0, 'NONE', 'not compressed'))
sound.writeframes(pv)
sound.close()
def hpFilter(block, f=filt1):
return block - np.convolve(block, f, 'same')
# for noiseAmplitude in [0, 100, 200, 500, 1000]:
# stagger the sounds: 1 m = 1/300th second = 130 samples
# a crowd of 1000 people could be placed in a semicircle of 50 people, 20 deep
# that makes the delta x about 10 m if they are "optimally aligned"
noiseAmplitude = 500
for spacing in np.arange(0,2,0.5):
stagger = int(spacing * 44100 / 340.)
duration = 78000
start = startPoints[0]-10*stagger
sumblock = addNoise(soundWave[start:start+duration], noiseAmplitude)
catblock = np.copy(sumblock)
# add the shifted samples:
for ii in range(1,19):
ti = startPoints[ii] +(ii-10)*stagger
temp = hpFilter(soundWave[ti:ti+duration])
sumblock = sumblock + temp;
catblock=np.r_[catblock, addNoise(temp, noiseAmplitude)]
writeFile(sumblock,'/Users/floris/Desktop/onewhisper_%d_s=%.1f.wav'%(noiseAmplitude, spacing))
writeFile(catblock, '/Users/floris/Desktop/evenwhisper_%d_s=%.1f.wav'%(noiseAmplitude, spacing))
plt.figure()
plt.plot(sumblock)
plt.title('sum signal: noise = %d'%noiseAmplitude)
plt.show()
With a "thank you!" to AccidentalFourierTransform who suggested using Archive.org as a possible place to host the audio files.