आश्रित यादृच्छिक चर का उत्पाद जब अपेक्षा करता है


18

और , आज्ञा दें । को रूप में क्या उम्मीद है ?X1U[0,1]XiU[Xi1,1]i=2,3,...X1X2Xnn


7
एक पंडिताऊ टिप्पणी: है XiU[Xi1,1] का इरादा करने के लिए मतलब XiX1,,Xi1U[Xi1,1] ? वैकल्पिक रूप से यह केवल पर कंडीशनिंग अर्थ हो सकता है Xi1 , यह है कि, XiXi1U[Xi1,1]। लेकिन बाद पूरी तरह से के संयुक्त वितरण निर्दिष्ट नहीं करता के रूप मेंXi है, यह तुरंत स्पष्ट नहीं है कि क्या उम्मीद विशिष्ट निर्धारित होता है।
जुहो कोक्कला

मुझे लगता है कि सैद्धांतिक रूप से इसे एक्स- आई - 1 तक सभी पिछले पर वातानुकूलित किया जाना चाहिए । हालाँकि, X i - 1 को देखते हुए हम X i के लिए वितरण प्राप्त कर सकते हैं । इसलिए मैं इस बारे में निश्चित नहीं हूं। XiXi1Xi1Xi
usedbywho

@JuhoKokkala जैसा कि आपने से पहले चरों पर कंडीशन करने से कोई फर्क नहीं पड़ता Xi1क्योंकि उन्होंने इस तथ्य को नहीं बदला कि Xi एकसमान है [Xi1,1] का वितरण (X1,,Xn)मुझे पूरी तरह से परिभाषित लगता है।
dsaxton

@dsaxton हम केवल यह मान तो X1U(0,1) और XiXi1U(Xi1,1),i=2,3,..., यह संभव है कि X1 और एक्स 2X3 पर सशर्त रूप से स्वतंत्र सशर्त नहीं हैं । इस प्रकार ( एक्स 1) का वितरणX2(X1,X2,X3) अच्छी तरह से परिभाषित नहीं है।
जुहो कोक्कल

@ जूहूकोक्कल अगर मैं आपको बताऊं कि X2=t , का वितरण क्या है X3? यदि आप बारे में सोचे बिना भी इस प्रश्न का उत्तर दे सकते हैं X1, तो X1 और X3 को X2 कैसे निर्भर किया जा सकता है ? यह भी ध्यान दें कि कैसे अन्य पोस्टरों को इस अनुक्रम को अनुकरण करने में कोई परेशानी नहीं हुई है।
dsaxton

जवाबों:


12

उत्तर वास्तव में 1/e , जैसा कि पहले के उत्तरों में अनुमान लगाया गया था कि सिमुलेशन और परिमित सन्निकटन पर आधारित है।

समाधान आसानी से आता है कार्यों का एक क्रम शुरू करने से fn:[0,1][0,1] । हालाँकि हम तुरंत उस कदम पर आगे बढ़ सकते थे, लेकिन यह रहस्यमयी प्रतीत हो सकता था। इस समाधान का पहला भाग बताता है कि कोई इन को कैसे पका सकता है fn(t)। दूसरे भाग से पता चलता है कि वे किस तरह का शोषण किया जाता एक कार्यात्मक समीकरण सीमित समारोह से संतुष्ट लगता है f(t)=limnfn(t)। तीसरा भाग इस क्रियात्मक समीकरण को हल करने के लिए आवश्यक (नियमित) गणनाओं को प्रदर्शित करता है।


1. प्रेरणा

हम कुछ मानक गणितीय समस्या-समाधान तकनीकों को लागू करके इस तक पहुंच सकते हैं। इस मामले में, जहां किसी प्रकार के ऑपरेशन को बार-बार एड इनफिनिटम कहा जाता है, सीमा उस ऑपरेशन के एक निश्चित बिंदु के रूप में मौजूद होगी । उसके बाद, कुंजी को ऑपरेशन की पहचान करना है।

कठिनाई यह है कि से कदम है E[X1X2Xn1] को E[X1X2Xn1Xn] जटिल लग। इस चरण को से समीपवर्ती X1चर से उत्पन्न होने के (X2,,Xn)बजाय Xn से चर ( X 1 ) के रूप में देखना सरल है । यदि हमप्रश्न में वर्णित अनुसार निर्मित किए जारहे ( एक्स 2 , , एक्स एन ) पर विचार कर रहे थे- एक्स 2 के साथसमान रूप से [ 0 , 1 ] पर वितरित किए गए, एक्स 3 सशर्त रूप से समान रूप से [ एक्स 2 , 1 ] , औरपर वितरित किए गएइतने पर - तो शुरू एक्स 1 बाद से हर एक कारण होगा एक्स मैं करने के लिए(X1,X2,,Xn1)(X2,,Xn)X2[0,1]X3[X2,1]X1Xiऊपरी सीमा 1 की ओर कारक से हटना1X11 । यह तर्क स्वाभाविक रूप से निम्नलिखित निर्माण की ओर ले जाता है।

प्रारंभिक बात के रूप में, चूँकि यह से 1 की ओर संख्या को सिकोड़ने के लिए थोड़ा सरल है , तो Y i = 1 - X i । इस प्रकार, Y 1 समान रूप में वितरित किया जाता है [ 0 , 1 ] और वाई मैं + 1 समान रूप में वितरित किया जाता है [ 0 , वाई मैं ] सशर्त पर ( Y 1 , वाई 2 , ... , वाई मैं ) सभी के लिए मैं01Yi=1XiY1[0,1]Yi+1[0,Yi](Y1,Y2,,Yi) हम दो चीजों में रुचि रखते हैं:i=1,2,3,.

  1. की सीमित मूल्य E[X1X2Xn]=E[(1Y1)(1Y2)(1Yn)]

  2. How these values behave when shrinking all the Yi uniformly towards 0: that is, by scaling them all by some common factor t, 0t1.

To this end, define

fn(t)=E[(1tY1)(1tY2)(1tYn)].

Clearly each fn is defined and continuous (infinitely differentiable, actually) for all real t. We will focus on their behavior for t[0,1].


2. The Key Step

The following are obvious:

  1. Each fn(t) is a monotonically decreasing function from [0,1] to [0,1].

  2. fn(t)>fn+1(t) for all n.

  3. fn(0)=1 for all n.

  4. E(X1X2Xn)=fn(1).

These imply that f(t)=limnfn(t) exists for all t[0,1] and f(0)=1.

Observe that, conditional on Y1, the variable Y2/Y1 is uniform in [0,1] and variables Yi+1/Y1 (conditional on all preceding variables) are uniform in [0,Yi/Y1]: that is, (Y2/Y1,Y3/Y1,,Yn/Y1) satisfy precisely the conditions satisfied by (Y1,,Yn1). Consequently

fn(t)=E[(1tY1)E[(1tY2)(1tYn)|Y1]]=E[(1tY1)E[(1tY1Y2Y1)(1tY1YnY1)|Y1]]=E[(1tY1)fn1(tY1)].

This is the recursive relationship we were looking for.

In the limit as n it must therefore be the case that for Y uniformly distributed in [0,1] independently of all the Yi,

f(t)=E[(1tY)f(tY)]=01(1ty)f(ty)dy=1t0t(1x)f(x)dx.

That is, f must be a fixed point of the functional L for which

L[g](t)=1t0t(1x)g(x)dx.

3. Calculation of the Solution

Clear the fraction 1/t by multiplying both sides by t. Because the right hand side is an integral, we may differentiate it with respect to t, giving

f(t)+tf(t)=(1t)f(t).

Equivalently, upon subtracting f(t) and dividing both sides by t,

f(t)=f(t)

for 0<t1. We may extend this by continuity to include t=0. With the initial condition (3) f(0)=1, the unique solution is

f(t)=et.

Consequently, by (4), the limiting expectation of X1X2Xn is f(1)=e1=1/e, QED.


Because Mathematica appears to be a popular tool for studying this problem, here is Mathematica code to compute and plot fn for small n. The plot of f1,f2,f3,f4 displays rapid convergence to et (shown as the black graph).

a = 0 <= t <= 1;
l[g_] := Function[{t}, (1/t) Integrate[(1 - x) g[x], {x, 0, t}, Assumptions -> a]];
f = Evaluate@Through[NestList[l, 1 - #/2 &, 3][t]]
Plot[f, {t,0,1}]

Figure


3
(+1) Beautiful analysis.
cardinal

Thank you for sharing that with us. There are some really brilliant people out there!
Felipe Gerard

4

Update

I think it's a safe bet that the answer is 1/e. I ran the integrals for the expected value from n=2 to n=100 using Mathematica and with n=100 I got

0.367879441171442321595523770161567628159853507344458757185018968311538556667710938369307469618599737077005261635286940285462842065735614

(to 100 decimal places). The reciprocal of that value is

2.718281828459045235360287471351873636852026081893477137766637293458245150821149822195768231483133554

The difference with that reciprocal and e is

-7.88860905221011806482437200330334265831479532397772375613947042032873*10^-31

I think that's too close, dare I say, to be a rational coincidence.

The Mathematica code follows:

Do[
 x = Table[ToExpression["x" <> ToString[i]], {i, n}];
 integrand = Expand[Simplify[(x[[n - 1]]/(1 - x[[n - 1]])) Integrate[x[[n]], {x[[n]], x[[n - 1]], 1}]]];
 Do[
   integrand = Expand[Simplify[x[[i - 1]] Integrate[integrand, {x[[i]], x[[i - 1]], 1}]/(1 - x[[i - 1]])]],
   {i, n - 1, 2, -1}]
  Print[{n, N[Integrate[integrand, {x1, 0, 1}], 100]}],
 {n, 2, 100}]

End of update

This is more of an extended comment than an answer.

If we go a brute force route by determining the expected value for several values of n, maybe someone will recognize a pattern and then be able to take a limit.

For n=5, we have the expected value of the product being

μn=01x11x21x31x41x1x2x3x4x5(1x1)(1x2)(1x3)(1x4)dx5dx4dx3dx2dx1

which is 96547/259200 or approximately 0.3724807098765432.

If we drop the integral from 0 to 1, we have a polynomial in x1 with the following results for n=1 to n=6 (and I've dropped the subscript to make things a bit easier to read):

x

(x+x2)/2

(5x+5x2+2x3)/12

(28x+28x2+13x3+3x4)/72

(1631x+1631x2+791x3+231x4+36x5)/4320

(96547x+96547x2+47617x3+14997x4+3132x5+360x6)/259200

If someone recognizes the form of the integer coefficients, then maybe a limit as n can be determined (after performing the integration from 0 to 1 that was removed to show the underlying polynomial).


1/e is beautifully elegant! :)
wolfies

4

Nice question. Just as a quick comment, I would note that:

  • Xn will converge to 1 rapidly, so for Monte Carlo checking, setting n=1000 will more than do the trick.

  • If Zn=X1X2Xn, then by Monte Carlo simulation, as n, E[Zn]0.367.

  • The following diagram compares the simulated Monte Carlo pdf of Zn to a Power Function distribution [ i.e. a Beta(a,1) pdf) ]

f(z)=aza1

... here with parameter a=0.57:


(source: tri.org.au)

where:

  • the blue curve denotes the Monte Carlo 'empirical' pdf of Zn
  • the red dashed curve is a PowerFunction pdf.

The fit appears pretty good.

Code

Here are 1 million pseudorandom drawings of the product Zn (say with n=1000), here using Mathematica:

data = Table[Times @@ NestList[RandomReal[{#, 1}] &, RandomReal[], 1000], {10^6}];

The sample mean is:

 Mean[data]

0.367657


can you share your entire code? My solution differs from yours.

1
The first bullet point, which is crucial, does not appear to be sufficiently well justified. Why can you dismiss the effect of, say, the next 10100 values of xn? Despite "rapid" convergence, their cumulative effect could considerably decrease the expectation.
whuber

1
Good use of simulation here. I have similar questions as @whuber. How can we be sure the value converges to 0.367 but not something lower, which is potentially possible if n is larger?
usedbywho

In reply to the above 2 comments: (a) The series Xi converges very rapidly to 1. Even starting with an initial value of X1=0.1, within about 60 iterations, X60 will be numerically indistinguishable from numerical 1.0 to a computer. So, simulating Xn with n=1000 is overkill. (b) As part of the Monte Carlo test, I also checked the same simulation (with 1 million runs) but using n=5000 rather than 1000, and the results were indistinguishable. Thus, it seem unlikely that larger values of n will make any discernible difference: above n=100, Xn is effectively 1.0.
wolfies

0

Purely intuitively, and based on Rusty's other answer, I think the answer should be something like this:

n = 1:1000
x = (1 + (n^2 - 1)/(n^2)) / 2
prod(x)

Which gives us 0.3583668. For each X, you are splitting the (a,1) range in half, where a starts out at 0. So it's a product of 1/2,(1+3/4)/2,(1+8/9)/2, etc.

This is just intuition.


The problem with Rusty's answer is that U[1] is identical in every single simulation. The simulations are not independent. A fix for this is easy. Move the line with U[1] = runif(1,0,1) to inside the first loop. The result is:

set.seed(3)    #Just for reproducibility of my solution

n = 1000    #Number of random variables
S = 1000    #Number of Monte Carlo samples

Z = rep(NA,S)
U = rep(NA,n)

for(j in 1:S){
    U[1] = runif(1,0,1)
    for(i in 2:n){
        U[i] = runif(1,U[i-1],1)
    }
    Z[j] = prod(U)
}

mean(Z)

This gives 0.3545284.


1
Very simple fix! I guess it is true, there is always a bug in the code! I'll take down my answer.

1
Yea, that was exactly what I was expecting to happen given that you plug in the expected values as the lower bounds.

1
I run your code with S=10000 and got 0.3631297 as the answer. Isn't that a little weird since if it does converge to a value wouldn't more runs get us closer to that value?
usedbywho
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.