स्रोत : विकिपीडिया लाइसेंस CC-BY-SA 3.0

यदि आप अक्सर सार्वजनिक परिवहन से यात्रा करते हैं, तो आप शायद इस स्थिति में आ गए हैं:

तुम एक पड़ाव पर आ जाओ। लिखा है कि बस हर 10 मिनट में चलती है। समय पर ध्यान दें ... आखिरकार, 11 मिनट के बाद, बस आती है और सोचा: मैं हमेशा अशुभ क्यों हूं?

सिद्धांत रूप में, यदि बसें प्रत्येक 10 मिनट में आती हैं, और आप एक यादृच्छिक समय पर पहुंचते हैं, तो औसत प्रतीक्षा लगभग 5 मिनट होनी चाहिए। लेकिन वास्तव में, बसें निर्धारित समय पर नहीं आती हैं, इसलिए आप अधिक समय तक इंतजार कर सकते हैं। यह पता चला है कि, कुछ उचित मान्यताओं के साथ, एक चौंकाने वाले निष्कर्ष पर आ सकते हैं:

हर 10 मिनट में औसतन आने वाली बस का इंतजार करते समय, आपका औसत प्रतीक्षा समय 10 मिनट होगा।

यह वही है जिसे कभी-कभी प्रतीक्षा समय विरोधाभास कहा जाता है ।

मुझे पहले एक विचार था, और मैं हमेशा सोचता था कि क्या यह वास्तव में सच है ... इस तरह की "उचित धारणाएं" वास्तविकता के अनुरूप हैं? इस लेख में, हम दोनों मॉडलिंग और संभाव्य तर्कों के संदर्भ में विलंबता विरोधाभास की जांच करते हैं, और फिर सिएटल में कुछ वास्तविक बस डेटा पर एक नज़र डालते हैं (उम्मीद है) एक बार और सभी के लिए विरोधाभास को हल करें।

विरोधाभास निरीक्षण

अगर बसें हर दस मिनट में आती हैं, तो औसत प्रतीक्षा समय 5 मिनट होगा। एक आसानी से समझ सकता है कि बसों के बीच अंतराल में बदलाव को जोड़ने से औसत प्रतीक्षा समय क्यों बढ़ जाता है।

प्रतीक्षा समय विरोधाभास एक अधिक सामान्य घटना का एक विशेष मामला है - निरीक्षण विरोधाभास , जिस पर एलन डाउनी के समझदार लेख, "निरीक्षण विरोधाभास हर जगह हमारे चारों ओर विस्तार से चर्चा की गई है। "

संक्षेप में, निरीक्षण विरोधाभास तब उत्पन्न होता है जब किसी मात्रा के अवलोकन की संभावना देखी गई मात्रा से संबंधित होती है। एलन अपनी कक्षाओं के औसत आकार के बारे में विश्वविद्यालय के छात्रों के सर्वेक्षण का एक उदाहरण देता है। हालाँकि स्कूल सच में एक समूह में 30 छात्रों की औसत संख्या की बात करता है, लेकिन छात्रों के दृष्टिकोण से औसत समूह का आकार बहुत बड़ा है। कारण यह है कि बड़ी कक्षाओं में (स्वाभाविक रूप से) अधिक छात्र होते हैं, जो उनके सर्वेक्षण के दौरान सामने आया है।

घोषित 10-मिनट के अंतराल के साथ बस अनुसूची के मामले में, कभी-कभी आगमन के बीच का अंतराल 10 मिनट से अधिक होता है, और कभी-कभी कम होता है। और यदि आप एक यादृच्छिक समय पर रुक जाते हैं, तो आप एक छोटे से एक लंबे अंतराल का सामना करने की अधिक संभावना रखते हैं। और इसलिए यह तर्कसंगत है कि प्रतीक्षा अंतराल के बीच औसत समय अंतराल बसों के बीच औसत समय अंतराल से अधिक लंबा है, क्योंकि नमूने में लंबे समय तक अंतराल अधिक आम है।

लेकिन विलंबता विरोधाभास एक मजबूत बयान देता है: यदि औसत बस रिक्ति है $$$एन$ मिनट, यात्रियों के लिए औसत प्रतीक्षा समय है $$$2N$ मिनट। क्या यह सच हो सकता है?

विलंबता का अनुकरण

खुद को इस के तर्क को समझाने के लिए, हम पहले 10 मिनट के औसत पर आने वाली बसों के प्रवाह का अनुकरण करते हैं। सटीकता के लिए, एक बड़ा नमूना लें: एक मिलियन बसें (या 10 मिनट के ट्रैफ़िक के लगभग 19 साल):

import numpy as np N = 1000000 # number of buses tau = 10 # average minutes between arrivals rand = np.random.RandomState(42) # universal random seed bus_arrival_times = N * tau * np.sort(rand.rand(N)) 

जांचें कि औसत अंतराल करीब है $$$\ tau = 10$ :

 intervals = np.diff(bus_arrival_times) intervals.mean() 

9.9999879601518398

अब हम समय की इस अवधि के दौरान एक बस स्टॉप पर बड़ी संख्या में यात्रियों के आगमन का अनुकरण कर सकते हैं और प्रतीक्षा समय की गणना कर सकते हैं जो उनमें से प्रत्येक अनुभव करता है। बाद में उपयोग के लिए एक फ़ंक्शन में कोड को एन्क्रिप्ट करें:

 def simulate_wait_times(arrival_times, rseed=8675309, # Jenny's random seed n_passengers=1000000): rand = np.random.RandomState(rseed) arrival_times = np.asarray(arrival_times) passenger_times = arrival_times.max() * rand.rand(n_passengers) # find the index of the next bus for each simulated passenger i = np.searchsorted(arrival_times, passenger_times, side='right') return arrival_times[i] - passenger_times 

फिर हम प्रतीक्षा समय का अनुकरण करते हैं और औसत की गणना करते हैं:

 wait_times = simulate_wait_times(bus_arrival_times) wait_times.mean() 

10.001584206227317

विरोधाभास की भविष्यवाणी के अनुसार औसत प्रतीक्षा समय 10 मिनट के करीब है।

गहरी खुदाई: संभावनाएं और पॉसन प्रक्रियाएं

ऐसी स्थिति का अनुकरण कैसे करें?

वास्तव में, यह एक निरीक्षण विरोधाभास का एक उदाहरण है, जहां किसी मूल्य के अवलोकन की संभावना स्वयं मूल्य से संबंधित है। द्वारा निरूपित करें $$$p (T)$ अंतराल के वितरण $$$T$ बस स्टॉप पर पहुंचते ही बसों के बीच। इस तरह के रिकॉर्ड में, आने वाले समय का अपेक्षित मूल्य होगा:

$$

$$E [T] = \ int_0 ^ \ infty T ~ p (T) ~ dT$$

पिछले सिमुलेशन में, हमने चयन किया $$$E [T] = \ tau = 10$ मिनट।

जब कोई यात्री किसी भी समय बस स्टॉप पर आता है, तो प्रतीक्षा समय की संभावना न केवल पर निर्भर करेगी $$$p (T)$ लेकिन से भी $$$T$ : अंतराल जितना बड़ा होगा, उसमें यात्री उतने ही अधिक होंगे।

इस प्रकार, हम यात्रियों के दृष्टिकोण से आने वाले समय के वितरण को लिख सकते हैं:

$$

$$p_ {exp} (T) \ propto T ~ p (T)$$

आनुपातिकता स्थिरांक वितरण के सामान्यीकरण से लिया गया है:

$$

$$p_ {exp} (T) = \ frac {T ~ p (T)} {\ int_0 ^ \ infty T ~ p (T) ~ dT}$$

यह सरल करता है

$$

$$p_ {exp} (T) = \ frac {T ~ p (T)} {E [T]}$$

फिर इंतजार का समय $$$ई [डब्ल्यू]$ यात्रियों के लिए अपेक्षित अंतराल होगा, इसलिए हम रिकॉर्ड कर सकते हैं

$$

$$E [W] = \ frac {1} {2} E_ {exp} [T] = \ frac {1} {2} \ int_0 ^ \ infty T ~ p_ {exp} (T) ~ dT$$

जिसे और अधिक समझने योग्य तरीके से लिखा जा सकता है:

$$

$$E [W] = \ frac {E [T ^ 2]} {2E [T]}$$

और अब यह केवल के लिए एक फार्म का चयन करने के लिए बनी हुई है $$$p (T)$ और अभिन्न की गणना।

पी (टी) की पसंद

एक औपचारिक मॉडल प्राप्त करने के बाद, इसके लिए एक उचित वितरण क्या है $$$p (T)$ ? हम वितरण की तस्वीर खींचेंगे $$$p (T)$ आगमन के बीच अंतराल के हिस्टोग्राम की साजिश रचकर हमारी नकली आवक के भीतर:

 %matplotlib inline import matplotlib.pyplot as plt plt.style.use('seaborn') plt.hist(intervals, bins=np.arange(80), density=True) plt.axvline(intervals.mean(), color='black', linestyle='dotted') plt.xlabel('Interval between arrivals (minutes)') plt.ylabel('Probability density'); 

यहां, ऊर्ध्वाधर धराशायी लाइन लगभग 10 मिनट का औसत अंतराल दिखाती है। यह एक घातीय वितरण के समान है, और दुर्घटना से नहीं: वर्दी यादृच्छिक संख्याओं के रूप में बस आगमन समय का हमारा अनुकरण पॉइसन प्रक्रिया के बहुत करीब है, और इस तरह की प्रक्रिया के लिए, अंतराल का वितरण घातीय है।

(नोट: हमारे मामले में, यह केवल एक अनुमानित घातांक है; वास्तव में, अंतराल $$$T$ के बीच $$$एन$ एक समय अवधि के भीतर समान रूप से चयनित अंक $$$एन \ ताऊ$ मैच का वितरण $$$T / (N \ tau) \ sim \ mathrm {Beta} [1, N]$ जो बड़ी सीमा में है $$$एन$ आ $$$T \ sim \ mathrm {Exp} [1 / \ tau]$ । अधिक जानकारी के लिए, आप पढ़ सकते हैं, उदाहरण के लिए, StackExchange पर एक पोस्ट या ट्विटर पर यह धागा )।

अंतराल के घातीय वितरण का तात्पर्य है कि आगमन का समय पोइसन प्रक्रिया का अनुसरण करता है। इस तर्क को सत्यापित करने के लिए, हम पॉसों प्रक्रिया की एक और संपत्ति की उपस्थिति की जांच करते हैं: कि निश्चित अवधि में आगमन की संख्या एक पॉइज़न वितरण है। ऐसा करने के लिए, हम सिम्युलेटेड आगमन को समय ब्लॉक में विभाजित करते हैं:

 from scipy.stats import poisson # count the number of arrivals in 1-hour bins binsize = 60 binned_arrivals = np.bincount((bus_arrival_times // binsize).astype(int)) x = np.arange(20) # plot the results plt.hist(binned_arrivals, bins=x - 0.5, density=True, alpha=0.5, label='simulation') plt.plot(x, poisson(binsize / tau).pmf(x), 'ok', label='Poisson prediction') plt.xlabel('Number of arrivals per hour') plt.ylabel('frequency') plt.legend(); 

अनुभवजन्य और सैद्धांतिक मूल्यों के करीबी पत्राचार हमें अपनी व्याख्या की शुद्धता के बारे में आश्वस्त करते हैं: बड़े के लिए $$$एन$ नकली आगमन का समय अच्छी तरह से पॉइसन प्रक्रिया द्वारा वर्णित किया गया है, जिसका अर्थ है कि तेजी से वितरित अंतराल।

इसका मतलब यह है कि संभावना वितरण लिखा जा सकता है:

$$

$$p (T) = \ frac {1} {\ tau} e ^ {- T / \ tau}$$

यदि हम पिछले सूत्र में परिणाम को प्रतिस्थापित करते हैं, तो हमें स्टॉप पर यात्रियों के लिए औसत प्रतीक्षा समय मिलेगा:

$$

$$E [W] = \ frac {\ int_0 ^ \ infty T ^ 2 ~ e ^ {- T / \ tau}} {2 \ int_0 ^ \ infty T ~ e ^ {- T / \ tau}} \ _ frac {2 \ tau ^ 3} {2 (\ tau ^ 2)} = \ tau$$

पॉसों प्रक्रिया के माध्यम से आगमन के साथ उड़ानों के लिए, अपेक्षित प्रतीक्षा समय आगमन के बीच औसत अंतराल के समान है।

इस समस्या को निम्नानुसार तर्क दिया जा सकता है: पॉइसन प्रक्रिया स्मृति के बिना एक प्रक्रिया है, अर्थात्, घटनाओं के इतिहास का अगले घटना के अपेक्षित समय से कोई लेना-देना नहीं है। इसलिए, बस स्टॉप पर पहुंचने पर, एक बस के लिए औसत प्रतीक्षा समय हमेशा एक ही होता है: हमारे मामले में, यह 10 मिनट है, भले ही पिछली बस से कितना समय बीत चुका हो! इससे कोई फर्क नहीं पड़ता कि आप कितने समय से प्रतीक्षा कर रहे हैं: अगली बस के लिए अपेक्षित समय हमेशा ठीक 10 मिनट है: पॉइसन प्रक्रिया में आपको प्रतीक्षा किए गए समय के लिए "क्रेडिट" नहीं मिलता है।

वास्तविकता समयबाह्य

उपरोक्त अच्छा है यदि वास्तविक बस आगमन वास्तव में पॉइसन प्रक्रिया द्वारा वर्णित है, लेकिन क्या ऐसा है?


स्रोत: सिएटल सार्वजनिक परिवहन योजना

आइए हम यह निर्धारित करने का प्रयास करें कि प्रतीक्षा समय का विरोधाभास वास्तविकता के अनुरूप कैसे है। ऐसा करने के लिए, हम यहाँ डाउनलोड करने के लिए उपलब्ध कुछ डेटा की जाँच करेंगे : आगमन_टाइम्स.वस्क (3 एमबी सीएसवी फ़ाइल)। डेटासेट में रैपिडराइड बसों सी, डी और ई के लिए नियोजित और वास्तविक आगमन समय होता है, और सिएटल शहर के तीसरे और पाइक बस स्टॉप पर। 2016 की दूसरी तिमाही में डेटा दर्ज किया गया था (इस फाइल के लिए वाशिंगटन स्टेट ट्रांसपोर्टेशन सेंटर से मार्क हॉलनबैक को धन्यवाद)।

 import pandas as pd df = pd.read_csv('arrival_times.csv') df = df.dropna(axis=0, how='any') df.head() 

	OPD_DATE	VEHICLE_ID	आरटीई	DIR	TRIP_ID	STOP_ID	STOP_NAME	SCH_STOP_TM	ACT_STOP_TM
0	2016/03/26	6201	673	एस	30908177	431	3RD AVE और PIKE ST (431)	01:11:57	01:13:19
1	2016/03/26	6201	673	एस	30908033	431	3RD AVE और PIKE ST (431)	23:19:57	23:16:13
2	2016/03/26	6201	673	एस	30908028	431	3RD AVE और PIKE ST (431)	21:19:57	21:18:46
3	2016/03/26	6201	673	एस	30908019	431	3RD AVE और PIKE ST (431)	19:04:57	19:01:49
4	2016/03/26	6201	673	एस	30908252	431	3RD AVE और PIKE ST (431)	16:42:57	16:42:39

मैंने रैपिडराइड डेटा को चुना, जिसमें अधिकांश दिन के लिए बसें 10-15 मिनट के नियमित अंतराल पर चलती हैं, इस तथ्य का उल्लेख नहीं करने के लिए कि मैं रूट सी का लगातार यात्री हूं।

डेटा की सफाई

सबसे पहले, हम इसे एक सुविधाजनक दृश्य में बदलने के लिए थोड़ा सा डेटा सफाई करेंगे:

 # combine date and time into a single timestamp df['scheduled'] = pd.to_datetime(df['OPD_DATE'] + ' ' + df['SCH_STOP_TM']) df['actual'] = pd.to_datetime(df['OPD_DATE'] + ' ' + df['ACT_STOP_TM']) # if scheduled & actual span midnight, then the actual day needs to be adjusted minute = np.timedelta64(1, 'm') hour = 60 * minute diff_hrs = (df['actual'] - df['scheduled']) / hour df.loc[diff_hrs > 20, 'actual'] -= 24 * hour df.loc[diff_hrs < -20, 'actual'] += 24 * hour df['minutes_late'] = (df['actual'] - df['scheduled']) / minute # map internal route codes to external route letters df['route'] = df['RTE'].replace({673: 'C', 674: 'D', 675: 'E'}).astype('category') df['direction'] = df['DIR'].replace({'N': 'northbound', 'S': 'southbound'}).astype('category') # extract useful columns df = df[['route', 'direction', 'scheduled', 'actual', 'minutes_late']].copy() df.head() 

	मार्ग	दिशा	समय सारिणी	तथ्य यह है। आगमन	तारबंदी (न्यूनतम)
0	सी	दक्षिण	2016-03-26 01:11:57	2016-03-26 01:13:19	1.366667
1	सी	दक्षिण	2016-03-26 23:19:57	2016-03-26 23:16:13	-३.७,३३,३३३
2	सी	दक्षिण	2016-03-26 21:19:57	2016-03-26 21:18:46	-१.१,८३,३३३
3	सी	दक्षिण	2016-03-26 19:04:57	2016-03-26 19:01:49	-३.१,३३,३३३
4	सी	दक्षिण	2016-03-26 16:42:57	2016-03-26 16:42:39	-.३,००,०००

बसें कितनी देर से चल रही हैं?

इस तालिका में छह डेटा सेट हैं: प्रत्येक मार्ग सी, डी और ई के लिए उत्तर और दक्षिण दिशाएं। उनकी विशेषताओं का पता लगाने के लिए, आइए इन छह में से प्रत्येक के लिए नियत समय के वास्तविक ऋण का हिस्टोग्राम बनाएं।

 import seaborn as sns g = sns.FacetGrid(df, row="direction", col="route") g.map(plt.hist, "minutes_late", bins=np.arange(-10, 20)) g.set_titles('{col_name} {row_name}') g.set_axis_labels('minutes late', 'number of buses'); 

यह मान लेना तर्कसंगत है कि बसें रूट की शुरुआत में शेड्यूल के करीब हैं और अंत से इसकी ओर अधिक जाती हैं। डेटा इसकी पुष्टि करते हैं: दक्षिणी मार्ग C पर हमारा रोक, साथ ही उत्तरी डी और ई मार्ग की शुरुआत के करीब है, और विपरीत दिशा में, अंतिम गंतव्य से दूर नहीं है।

अनुसूचित और मनाया अंतराल

इन छह मार्गों के लिए देखे गए और नियोजित बस अंतराल पर एक नज़र डालें। आइए इन अंतरालों की गणना करने के लिए पंडों में groupby फ़ंक्शन के साथ शुरू करें:

 def compute_headway(scheduled): minute = np.timedelta64(1, 'm') return scheduled.sort_values().diff() / minute grouped = df.groupby(['route', 'direction']) df['actual_interval'] = grouped['actual'].transform(compute_headway) df['scheduled_interval'] = grouped['scheduled'].transform(compute_headway) 

 g = sns.FacetGrid(df.dropna(), row="direction", col="route") g.map(plt.hist, "actual_interval", bins=np.arange(50) + 0.5) g.set_titles('{col_name} {row_name}') g.set_axis_labels('actual interval (minutes)', 'number of buses'); 

यह पहले से ही स्पष्ट है कि परिणाम हमारे मॉडल के घातीय वितरण के समान नहीं हैं, लेकिन यह अभी भी कुछ नहीं कहता है: ग्राफ़ में असंगत अंतराल से वितरण प्रभावित हो सकता है।

आइए देखे गए अंतराल के बजाय नियोजित, आरेखों के निर्माण को दोहराएं।

 g = sns.FacetGrid(df.dropna(), row="direction", col="route") g.map(plt.hist, "scheduled_interval", bins=np.arange(20) - 0.5) g.set_titles('{col_name} {row_name}') g.set_axis_labels('scheduled interval (minutes)', 'frequency'); 

इससे पता चलता है कि सप्ताह के दौरान बसें अलग-अलग अंतराल पर चलती हैं, इसलिए हम बस स्टॉप से ​​वास्तविक जानकारी का उपयोग करके प्रतीक्षा समय विरोधाभास की सटीकता का अनुमान नहीं लगा सकते हैं।

यूनिफॉर्म का शेड्यूल बनाना

हालांकि आधिकारिक कार्यक्रम समान अंतराल नहीं देता है, बड़ी संख्या में बसों के साथ कई विशिष्ट समय अंतराल हैं: उदाहरण के लिए, उत्तर की ओर मार्ग ई के लगभग 2000 बसें 10 मिनट के नियोजित अंतराल के साथ। यह पता लगाने के लिए कि क्या विलंबता विरोधाभास लागू है, आइए डेटा को मार्गों, दिशाओं और नियोजित अंतराल में समूहित करें, और फिर उन्हें फिर से स्टैक करें जैसे कि वे क्रमिक रूप से हुए थे। यह विलंबता विरोधाभास की भविष्यवाणियों के साथ प्रत्यक्ष तुलना की सुविधा देते हुए, स्रोत डेटा की सभी प्रासंगिक विशेषताओं को संरक्षित करना चाहिए।

 def stack_sequence(data): # first, sort by scheduled time data = data.sort_values('scheduled') # re-stack data & recompute relevant quantities data['scheduled'] = data['scheduled_interval'].cumsum() data['actual'] = data['scheduled'] + data['minutes_late'] data['actual_interval'] = data['actual'].sort_values().diff() return data subset = df[df.scheduled_interval.isin([10, 12, 15])] grouped = subset.groupby(['route', 'direction', 'scheduled_interval']) sequenced = grouped.apply(stack_sequence).reset_index(drop=True) sequenced.head() 

	मार्ग	दिशा	समय सारिणी	तथ्य यह है। आगमन	तारबंदी (न्यूनतम)	तथ्य यह है। अंतराल	अनुसूचित अंतराल
0	सी	उत्तर	10.0	12.400000	2.400000	NaN	10.0
1	सी	उत्तर	20.0	27.150000	7.150000	0.183333	10.0
2	सी	उत्तर	30.0	26.966667	-३.०,३३,३३३	14.566667	10.0
3	सी	उत्तर	40.0	35.516667	-४.४,८३,३३३	8.366667	10.0
4	सी	उत्तर	50.0	53.583333	3.583333	18.066667	10.0

क्लियर किए गए डेटा पर, आप आगमन की आवृत्ति के साथ प्रत्येक मार्ग और दिशा में बसों की वास्तविक उपस्थिति के वितरण का एक ग्राफ बना सकते हैं:

 for route in ['C', 'D', 'E']: g = sns.FacetGrid(sequenced.query(f"route == '{route}'"), row="direction", col="scheduled_interval") g.map(plt.hist, "actual_interval", bins=np.arange(40) + 0.5) g.set_titles('{row_name} ({col_name:.0f} min)') g.set_axis_labels('actual interval (min)', 'count') g.fig.set_size_inches(8, 4) g.fig.suptitle(f'{route} line', y=1.05, fontsize=14) 

हम देखते हैं कि प्रत्येक मार्ग के लिए मनाया अंतराल का वितरण लगभग गौसियन है। यह नियोजित अंतराल के पास स्थित है और इसमें एक मानक विचलन है जो मार्ग की शुरुआत में कम है (सी के लिए दक्षिण, डी / ई के लिए उत्तर) और अंत में अधिक है। दृष्टि से भी, वास्तविक आगमन अंतराल निश्चित रूप से घातीय वितरण के अनुरूप नहीं है, जो कि मुख्य धारणा है जिस पर प्रतीक्षा समय विरोधाभास आधारित है।

हम प्रतीक्षा समय सिमुलेशन फ़ंक्शन ले सकते हैं जिसका उपयोग हमने प्रत्येक बस मार्ग, दिशा और समय के लिए औसत प्रतीक्षा समय खोजने के लिए किया था:

 grouped = sequenced.groupby(['route', 'direction', 'scheduled_interval']) sims = grouped['actual'].apply(simulate_wait_times) sims.apply(lambda times: "{0:.1f} +/- {1:.1f}".format(times.mean(), times.std())) 

  मार्ग निर्देशन अनुसूचित अंतराल
 C उत्तर 10.0 7.8 +/- 12.5
                       12.0 7.4 +/- 5.7
                       15.0 8.8 +/- 6.4
          दक्षिण 10.0 6.2 +/- 6.3
                       12.0 6.8 +/- 5.2
                       15.0 8.4 +/- 7.3
 D उत्तर 10.0 6.1 +/- 7.1
                       12.0 6.5 +/- 4.6
                       15.0 7.9 +/- 5.3
          दक्षिण 10.0 6.7 +/- 5.3
                       12.0 7.5 +/- 5.9
                       15.0 8.8 +/- 6.5
 ई उत्तर 10.0 5.5 +/- 3.7
                       12.0 6.5 +/- 4.3
                       15.0 7.9 +/- 4.9
          दक्षिण 10.0 6.8 +/- 5.6
                       12.0 7.3 +/- 5.2
                       15.0 8.7 +/- 6.0
 नाम: वास्तविक, dtype: ऑब्जेक्ट 

औसत प्रतीक्षा समय, शायद एक या दो मिनट, योजनाबद्ध अंतराल से आधे से अधिक है, लेकिन नियत अंतराल के बराबर नहीं है, क्योंकि प्रतीक्षा समय विरोधाभास का अर्थ है। दूसरे शब्दों में, निरीक्षण विरोधाभास की पुष्टि की जाती है, लेकिन प्रतीक्षा समय विरोधाभास सच नहीं है।

निष्कर्ष

विलंबता विरोधाभास एक चर्चा के लिए एक दिलचस्प शुरुआती बिंदु था जिसमें मॉडलिंग, संभावना सिद्धांत और वास्तविकता के साथ सांख्यिकीय मान्यताओं की तुलना करना शामिल था। यद्यपि हमने पुष्टि की है कि वास्तविक दुनिया में, बस मार्ग किसी प्रकार के निरीक्षण विरोधाभास का पालन करते हैं, उपरोक्त विश्लेषण काफी स्पष्ट रूप से दर्शाता है: प्रतीक्षा समय विरोधाभास को अंतर्निहित मुख्य धारणा - कि बसों का आगमन पॉइज़न प्रक्रिया के आंकड़ों का पालन करता है - उचित नहीं है।

पूर्वव्यापी में, यह आश्चर्य की बात नहीं है: पॉइसन प्रक्रिया एक स्मृतिहीन प्रक्रिया है जो मानती है कि आगमन की संभावना पिछले आगमन के बाद के समय से पूरी तरह से स्वतंत्र है। वास्तव में, एक अच्छी तरह से प्रबंधित सार्वजनिक परिवहन प्रणाली ने इस व्यवहार से बचने के लिए विशेष रूप से संरचित समय सारिणी बनाई है: बसें दिन के दौरान यादृच्छिक समय पर अपने मार्गों को शुरू नहीं करती हैं, लेकिन यात्रियों के सबसे कुशल परिवहन के लिए चुने गए कार्यक्रम के अनुसार शुरू होती हैं।

अधिक महत्वपूर्ण सबक किसी भी डेटा विश्लेषण कार्य के बारे में आपके द्वारा की जाने वाली मान्यताओं के बारे में सावधान रहना है। कभी-कभी पोइज़न प्रक्रिया आगमन के समय के आंकड़ों के लिए एक अच्छा विवरण है। लेकिन सिर्फ इसलिए कि एक डेटा प्रकार एक और डेटा प्रकार की तरह लगता है, इसका मतलब यह नहीं है कि एक के लिए अनुमत धारणाएं दूसरे के लिए आवश्यक रूप से मान्य हैं। अक्सर ऐसी धारणाएँ जो सही प्रतीत होती हैं, उन निष्कर्षों को जन्म दे सकती हैं जो सच नहीं हैं।