Pour les “n” plus grands, le max est plus proche de d’être égal à “a”. Mais si le “a” est grand, donc l’espace será plus grand aussi. Ce que vais reduire la probabilité de que max(X) soit égal à “a”
set.seed(0)
a = 3
n = 10000
X = runif(n, min=0, max = a)
m = max(X)
print(c(a, m))
## [1] 3.000000 2.999792
La fonction de densité du max de X est égal à la chance qu’il soit x fois la chance que les autres tirages sont plus petites au égal à x.
Donc, \(f_m(x) = P(X = x) * P(X <= x)^n\)
\(f_m(x) = dx * (x/a)^n\)
La raison que \(P(X = x) = dx\) c’est a cause de que l’intervalle est réel, donc la probabilité est ~0. Pour \(P(X <= x) = x / a\), c’est a cause que l’espace desiré é [0, x] et le total est [0, a]. Donc c’est \((x - 0)/(a - 0)\). En effet, ça c’est la fonction de repartion initial.
Comme il y a dx dans la fonction, il faut la dériver, ce que retourne \(n*x^{n-1}/a^n\).
Donc, \[E[M] = \int_{-\infty}^{\infty} x f_m(x) dx = \int_{0}^{a} x f_m(x) dx\]
\[E[M] = \int_0^a x * \frac{n*x^{(n-1)}}{a^n} dx = \frac{n}{a^n} \int_0^a x * x^{n - 1} dx\]
\[E[M] = \frac{n}{a^n} \left[ \frac{x^{n+1}}{n+1} \right]_0^a = \frac{n}{a^n} \left[ \frac{a^{n+1} - 0^{n+1}}{n + 1} \right]\]
\[E[M] = \frac{n}{n+1}a\]
e = a * n / (n + 1)
print(c(m, e))
## [1] 2.999792 2.999700
Si, en applicant l’equation, c’est possible de trouver une bonne approximation du max, basée sur n et a. Alors, l’operation inverse c’est ce que trouvera a basée sur n et max.
aprox = m * (n+1) / n
print(c(aprox, a))
## [1] 3.000092 3.000000
Y = c()
N = seq(100, 1000, by=100)
A = seq(1, 100, by=10)
for (n in N){
for (a in A){
Y = append(Y, var(replicate(50, max(runif(n, min=0, max = a)))))
}
}
Mmaxvar = matrix(Y, nrow=length(A), ncol=length(N))
image(A, N, Mmaxvar)
Mmaxvar
## [,1] [,2] [,3] [,4] [,5]
## [1,] 0.0001079158 3.877999e-05 1.681437e-05 0.0000062016 3.180473e-06
## [2,] 0.0044147298 2.890355e-03 2.136328e-03 0.0004480809 8.332368e-04
## [3,] 0.0289193623 1.103461e-02 5.393287e-03 0.0020043364 2.374492e-03
## [4,] 0.0614323800 1.136962e-02 1.287930e-02 0.0047720617 7.038439e-03
## [5,] 0.0783192484 3.474950e-02 2.350610e-02 0.0076748247 4.560304e-03
## [6,] 0.1944958096 7.822897e-02 1.630429e-02 0.0112307650 7.211297e-03
## [7,] 0.4156999518 8.214695e-02 3.389891e-02 0.0225815365 1.087726e-02
## [8,] 0.5400902407 9.936887e-02 4.933577e-02 0.0410354866 2.793629e-02
## [9,] 0.4611229375 1.207794e-01 6.197942e-02 0.0373262902 2.387586e-02
## [10,] 0.3261530337 1.359571e-01 7.554122e-02 0.0523081362 1.607673e-02
## [,6] [,7] [,8] [,9] [,10]
## [1,] 3.453767e-06 1.449365e-06 1.437121e-06 1.487314e-06 1.065713e-06
## [2,] 2.514008e-04 1.731978e-04 3.062588e-04 8.055229e-05 1.850090e-04
## [3,] 1.212431e-03 6.179494e-04 4.944744e-04 7.116082e-04 1.259375e-03
## [4,] 3.206106e-03 3.043270e-03 9.554054e-04 1.210556e-03 4.481227e-04
## [5,] 4.433471e-03 5.229871e-03 6.357403e-03 1.076573e-03 1.365749e-03
## [6,] 3.239456e-03 4.060197e-03 3.507059e-03 5.767513e-03 2.278426e-03
## [7,] 1.366768e-02 6.725208e-03 1.031477e-02 3.955891e-03 4.502262e-03
## [8,] 1.151057e-02 5.512232e-03 1.024719e-02 5.888731e-03 3.563003e-03
## [9,] 1.480771e-02 1.334613e-02 1.263260e-02 4.673682e-03 6.853639e-03
## [10,] 1.760903e-02 9.336319e-03 1.374787e-02 1.014708e-02 6.980501e-03
C’est notable que pour les a plus grands, la variance augmentera et pour les n plus grandes, la variance diminuera. Mais je ne suis pas capable de dire une equation pour estimer la variance.
avg = mean(X)
2*avg
## [1] 3.001512
Il est aussi proche de a. Comme M´ n’est que deux fois la moyenne, c’est possible d’utiliser 2 fois l’espérance. Une information importante ce que la distribuition est uniforme, ce que ferait que l’espérance soit proche de \(a/2\).
La preuve:
Comme la Fonction de repartition est \(x/a\), la fonction de densité est le dérivé (\(1/a\)). Donc,
\[E[X] = \int_{-\infty}^{\infty}x * f_x dx = \int_0^{a} \frac{x}{a} dx = \left[ \frac{x^2}{2a} \right]_0^a\] \[E[X] = \frac{a}{2}\]
Y = c()
N = seq(100, 1000, by=100)
A = seq(1, 100, by=10)
for (n in N){
for (a in A){
Y = append(Y, var(replicate(50, mean(runif(n, min=0, max = a)))))
}
}
Mavgvar = matrix(Y, nrow=length(A), ncol=length(N))
#image(A, N, X)
round((Mavgvar - Mmaxvar)/Mmaxvar)
## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## [1,] 6 13 13 46 38 39 51 72 59 82
## [2,] 31 18 10 52 27 68 87 46 159 56
## [3,] 14 14 14 44 33 43 63 110 78 24
## [4,] 11 31 24 40 19 55 49 112 70 201
## [5,] 22 22 16 44 80 42 28 22 122 111
## [6,] 9 12 37 38 61 156 90 70 36 99
## [7,] 9 14 41 32 63 39 59 42 77 47
## [8,] 7 23 21 20 19 51 116 65 66 119
## [9,] 8 28 32 40 46 51 66 47 99 59
## [10,] 18 29 26 32 70 59 116 50 53 93
Ce tableau montre la diference (en pourcentage) entre M et M´. C’est facile a voir que a chaque ligne (que represente A) que, à mesure que n grandit, la différance s’agrandit.
Je suppose que c’est pas une bonne stratégie. Comme vu dans le Q1.1, c’est possible d’avoir \(1.1M > a\). Comme 1.1 c’est avoir un valeur plus proche plusier fois, il prendre em compte que avoir que $1.1M > a $ est encore une bonne option, ce que est pas le cas a ce moment.
a = runif(1)
n = 10
#the runif is a single game simulation and the max is the value M alice returns.
#Replicate will run the game 100 times
X = replicate(100, max(runif(n, min=0, max = a)))
#This shows the chances on which 1.1M > a
mean(X*1.1 <= a)
## [1] 0.38
#This shows Bob's total gain on all 100 games
sum(X[1.1*X <= a] * 0.1)
## [1] 0.4548883
En effet, seulement 36% de fois que 1.1M était plus petit que a.
q12 <- function(){
a = sample(seq(0, 1, 0.1), size=1, replace = TRUE)
n = 3
#the runif is a single game simulation and the max is the value M alice returns.
#Replicate will run the game 100 times
X = replicate(100, max(sample(seq(0, a, 0.1), size=n, replace = TRUE)))
#This shows the chances on which 1.1M > a
m = mean(X*1.1 <= a)
#This shows Bob's total gain on all 100 games
g = sum(X[1.1*X <= a] * 0.1)
print(c(a, m, g))
}
#a gain chances total gain
for(i in 1:10){
q12()
}
## [1] 0.70 0.72 3.55
## [1] 0.10 0.14 0.00
## [1] 0.30 0.43 0.69
## [1] 0.80 0.65 3.41
## [1] 0.20 0.26 0.24
## [1] 0.60 0.57 2.14
## [1] 0.70 0.64 3.12
## [1] 0.90 0.79 4.68
## [1] 0.10 0.16 0.00
## [1] 0.30 0.40 0.61
# a single game returns an a when a expected m is fount
game <- function(n, fixedM){
m = -1
while(TRUE){
a = sample(seq(0, 1, 0.1), size=1, replace = TRUE)
m = max(sample(seq(0, a, 0.1), size=n, replace = TRUE))
#I had problems for values different than 0.5 to see if they were equal, therefore an
#epsilon was taken to consider if they were equal.
if( abs(fixedM - m) < 0.05 ){
return(a)
}
}
}
n = 3
fixedM = 0.5
A = replicate(1000, game(n, fixedM))
for(i in seq(fixedM, 1, by=0.1)){
print(c(i, sum( (i <= A)*(i - fixedM)), sum(i <= A) ))
}
## [1] 5e-01 0e+00 1e+03
## [1] 0.6 61.2 612.0
## [1] 0.7 76.4 382.0
## [1] 0.8 66.9 223.0
## [1] 0.9 53.6 134.0
## [1] 1 31 62
La valeur optimale est 0.7, que c’est la quantité qu’il gagne (\(0.7 - 0.5 = 0.2\)) fois combien de fois il gagne.
à suivre, à gauche, il y a les valeurs de M. à droite, les r(M) optimales, découvert en utilisant le code de la question précédent
0.0 -> 0.1 0.1 -> 0.3 0.2 -> 0.5 0.3 -> 0.6 0.4 -> 0.6 0.5 -> 0.7 0.6 -> 0.8 0.7 -> 0.9 0.8 -> 0.9 0.9 -> 1.0
Oui c’est une bonne stratégie. Comparer les valeurs calculées à la question d’avant, avec la nouvelle stratégie (\(\alpha = 0.5\)), les valeurs sont bien proches.
step = seq(0, 0.9, by=0.1)
x = c(0, 0.1/0.3, 0.2/0.5, 0.3/0.6, 0.4/0.6, 0.5/0.7, 0.6/0.8, 0.7/0.9, 0.8/0.9, 0.9)
y = step**0.5
plot(step, x, type = "l")
lines(step, y, type = "l", col='red')
game_alpha<-function(alpha, n=2){
error = c()
for(a in seq(0, 1, by=0.01)){
#For a certain value of alpha, all values of a will be tested and checked the difference with
#the calculated value. the difference is squared so the differences don't cancel each other out.
X = mean(replicate(100, max(sample(seq(0, a, 0.1), size=n, replace = TRUE))))
error = append(error, (a - X**alpha)**2)
}
return(sum(error))
}
for(alpha in c(0.3, 0.5, 0.7)){
print(c(alpha, game_alpha(alpha)))
}
## [1] 0.300000 4.075326
## [1] 0.500000 1.130361
## [1] 0.700000 1.519958
parmi les 3 valeurs proposées, 0.5 est la plus précise.
for(alpha in c(0.3, 0.5, 0.7)){
print(c(alpha, game_alpha(alpha, n=10)))
}
## [1] 0.300000 6.226634
## [1] 0.500000 1.925362
## [1] 0.7000000 0.3857695
La situation change et 0,7 est a ce moment la meilleure option.