Michaël a écrit 2935 commentaires

En gros, tu peux y mettre des statistiques, de la théorie des jeux, des systèmes de vote, et tu as à peu près fait le tour des maths pures ancrées dans le réel.

Enfin ça laisse pas mal de champ, même en oubliant quand même un peu la géométrie, l'arithmétique, et le calcul différentiel (niveau lycée).

Je trouve que poser des problèmes du type de ceux-cis est complètement anti-pédagogique parceque ça entraîne à faire des choses qui ne sont jamais utiles dans la vie (qu'on soit mathématicien ou pas): formaliser des situations qui sont faciles à formaliser (c'est fait pour) mais présentées de façon absurdement compliquées.

Bravo pour la résolution des problèmes. Je suis preneur d'exercices moins artificiels si tu as.

Merci! Ma critique est adressée aux rédacteurs des épreuves. :-)

1. Ah j'ai raté mon regroupement, mais les autres l'ont bien fait.

On peut admirer les exercices complètement artificiels, du genre de ceux qui arrivent à convaincre les populations que 1/les maths ne servent à rien 2/que c'est horrible. Si on veut poser des problèmes pratiques plutôt que des problèmes abstraits on peut mieux faire!

1. Soit le volume en litres de la première pièce de vin, d'après l'énoncé on a

soit après développement et regroupement

Le volume recherché est donc une racine de l'équation du second degré

Le discriminant de cette équation est

Ce discriminant est positif est notre équation du second degré a deux racines réelles, puisque son terme linéaire est positif seule la racine

est positive, elle est donc le volume recherché.

1. À tout réel on associe la distance carrée () des deux trains heures après 12h. On cherche le minimum de cette fonction. Soit le vecteur différence des positions du train à et soit le vecteur de leur différence de vitesse horaire. On a donc

en notant la norme de tout vecteur et le produit scalaire des vecteurs et .

D'après l'énoncé

On trouve ainsi

et le minimum de l'équation la quadrique est atteint au point où sa dérivée

s'annule. On trouve ainsi de sorte que les trains sont le plus proche à 12h10.

L'age d'abord, j'ai déjà fait deux carrière, et si je voulais en faire une troisième il était tant de s'y mettre.

Ah ah pareil… deux ou trois de mon côté :-)

Pour le sujet […], c'est venu un peu en réaction de mon métier précédant.

Après avoir fait de la recherche en maths j'ai du travailler dans l'industrie (précarité des chercheurs) et de fil en aiguille amélioré ma situation… pour me rendre compte que je ne fais pas des choses très stimulantes ou ambitieuses intellectuellement, que je suis (à la fois trop et pas assez) payé à faire un travail dont la contribution au bien commun est loin d'être évidente, etc. Donc au final enseigner me semble une perspective plus réjouissante! :-)

Ah je l'ai: le problème est si a == b où à la fin de l'itération people[a] == people[b] vaut aléatoirement l'une des deux valeurs renvoyée par pays alors que rien ne devrait se passer.

En faisant un exemple avec une plus grande population (1 million) et un grand nombre de transaction (10000 par acteur, soit 10000 millions ici) on arrive à

CL-USER> (let ((*regulatory-advantage* 5/100)
           (*population-size* 1000000))
(fortune-repartition (fortune-simulation (* *population-size* 10000))
             1/2 3/4 90/100 95/100))
((0.95 34643 1.9000037e9) (0.9 23940 1.8000128e9) (0.75 11779 1.5000092e9)
 (0.5 4583 1.0000814e9))

ce qui fait que les 34643 personnes les plus riches détiennent à elles seules plus de 95% du patrimoine total!

Pourtant si je regarde ce que vaut customer + seller à l'entrée de la fonction pays et à la sortie, cette quantité est invariante.

Pour en avoir le cœur net j'ai écrit une alternative à pays qui met cela bien en évidence:

def pays(customer, seller, base):
    amount = 0
    # no advantage for the poorest as no poorest
    if seller == customer:
        amount = base * RATE
    # poorest receive the money so add DRATE in the transfer
    elif seller > customer:
        amount = base * (RATE + DRATE)
    # poorest pay the money so deduct DRATE in the transfer
    else:
        amount = base * (RATE - DRATE)
    return (seller + amount, customer - amount)

et ajouté des print dans le programme pour tracer:

for _ in range(0, NB_LOOP):
    # select two random people
    a = randint(0, NB_PEOPLE - 1)
    b = randint(0, NB_PEOPLE - 1)

base = min(people[a], people[b])
``` invariant1 = people[a] + people[b]
print(f"1st people[a], people[b] {people[a]}, {people[b]}")
u, v = pays2(people[a], people[b], base)
print(f"u,v ={u}, {v}")
people[a], people[b] = u, v
print(f"2nd people[a], people[b] {people[a]}, {people[b]}")
invariant2 = people[a] + people[b]
assert(invariant1 == invariant2)
~~~

et ça me fait un truc du genre:

1st people[a], people[b] 2000, 2000
u,v =2400.0, 1600.0
2nd people[a], people[b] 2400.0, 1600.0
1st people[a], people[b] 1600.0, 2000
u,v =2400.0, 1200.0
2nd people[a], people[b] 2400.0, 1200.0
1st people[a], people[b] 2000, 2000
u,v =2400.0, 1600.0
2nd people[a], people[b] 2400.0, 1600.0
1st people[a], people[b] 2400.0, 1200.0
u,v =1380.0, 2220.0
2nd people[a], people[b] 1380.0, 2220.0
1st people[a], people[b] 2000, 2000
u,v =2400.0, 1600.0
2nd people[a], people[b] 2400.0, 1600.0
1st people[a], people[b] 2400.0, 2400.0
u,v =2880.0, 1920.0
2nd people[a], people[b] 2880.0, 1920.0
1st people[a], people[b] 2000, 2880.0
u,v =3380.0, 1500.0
2nd people[a], people[b] 3380.0, 1500.0
1st people[a], people[b] 1920.0, 2400.0
u,v =2880.0, 1440.0
2nd people[a], people[b] 2880.0, 1440.0
1st people[a], people[b] 1500.0, 1600.0
u,v =1975.0, 1125.0
2nd people[a], people[b] 1975.0, 1125.0
1st people[a], people[b] 1600.0, 3380.0
u,v =3780.0, 1200.0
2nd people[a], people[b] 3780.0, 1200.0
1st people[a], people[b] 2000, 1440.0
u,v =1656.0, 1784.0
2nd people[a], people[b] 1656.0, 1784.0
1st people[a], people[b] 2000, 1200.0
u,v =1380.0, 1820.0
2nd people[a], people[b] 1380.0, 1820.0
1st people[a], people[b] 1380.0, 1380.0
u,v =1656.0, 1104.0
2nd people[a], people[b] 1104.0, 1104.0
Traceback (most recent call last):
  File "/Users/michael/Desktop/example.py", line 70, in <module>
    assert(invariant1 == invariant2)

On voit que l'affectation de deux variables en même temps genre marche de façon bizarre dans la dernière trace: même si u et v ont les bonnes valeurs (on a 1656 + 1104 == 1380 + 1380) tout se casse la gueule quand on fait l'affectation à people[a], people[b]. Que se passe-t-il?

PS: Mon commentaire fait foirer markdown de façon aussi magistrale qu'inattendue!

. Ici la planche à billet tourne à fond les ballons (il y a 50 fois plus d'argent qu'à l'état initial)

C'est louche que la masse monétaire augmente puisque la simulation n'introduit jamais d'argent supplémentaire. Tu es sûr de ça?

Je suis maintenant prof de math (changement de carrière).

Ah c'est marrant moi aussi je fais ça à partir de septembre. Qu'est-ce qui t'a fait changer?

Comme je n'ai pas envie de dormir et que ce que tu dis est très intéressant j'ai écrit ton programme en Common Lisp – utilisable abec sbcl par exemple. Cela ressemble à ça:

(defparameter *population-size* 500
  "The number of persons in our modelisation.")

(defparameter *initial-fortune* 2000
  "The initial fortune of each person in the modelisation.")

(defparameter *transaction-rate* 20/100
  "The proportion of their fortune a person will engage in a transaction.")

(defparameter *regulatory-advantage* 5/100
  "The correction introduces by the regulator to alleviate the poor.")


(defun fortune-simulation (number-of-iterations)
  "Run the Boghosian model for NUMBER-OF-ITERATIONS."
  (declare (optimize (speed 3)))
  (labels
      ((make-initial-state ()
     (make-array *population-size* :initial-element (float *initial-fortune*)))
       (transaction (state)
     (let* ((payer
          (random *population-size*))
        (receiver
          (random *population-size*))
        (fortune-payer
          (aref state payer))
        (fortune-receiver
          (aref state receiver))
        (transaction-base
          (min fortune-payer fortune-receiver))
        (transaction-rate
          (float
           (if (> fortune-payer fortune-receiver)
               (+ *transaction-rate* *regulatory-advantage*)
               *transaction-rate*)))
        (transaction-amount
          (* transaction-base transaction-rate)))
       (decf (aref state payer) transaction-amount)
       (incf (aref state receiver) transaction-amount))))
    (let ((state (make-initial-state)))
      (dotimes (_ number-of-iterations state) (transaction state)))))

La fonction calcule l'état final du modèle après tant et tant d'itérations. Cet état est juste le vecteur des fortunes. (Pourquoi ne pas donner 1 EUR à tout le monde au début au lieu de 2000 ? :-) )

Pour interpréter les résultats plus facilement j'ai aussi écrit la fonction suivante

(defun fortune-repartition (fortune-vector &rest query)
  "Analyse fortune repartition according to request QUERY.

The QUERY is a list of percentages to break down the fortune repartition. The answer
is a list whose elements have the form

  (P N AMOUNT)

which reads like

  “In FORTUNE-VECTOR the N-th first people own together AMOUNT of money,
   which is more than P of the total amount of money.”
"
  (let*
      ((total-fortune
     (* *population-size* *initial-fortune*))
       (decreasing-fortune
     (sort fortune-vector #'>=))
       (detailed-query
     (mapcar #'(lambda (p) (cons (float p) (float (* p total-fortune))))
         (sort query #'<=))))
    (loop with current-query = detailed-query
      with answer = nil
      for i from 1 upto *population-size*
      for ax = (aref decreasing-fortune 0) then (+ ax (aref decreasing-fortune (1- i)))
      when (null current-query)
      do (return answer)
      when (>= ax (cdr (first current-query)))
      do (progn
           (push (list (car (first current-query)) i ax) answer)
           (setf current-query (rest current-query)))
      finally (return answer))))

Au final avec les nombres que tu utilises mais seulement 100000 simulations, on trouve:

CL-USER> (fortune-repartition (fortune-simulation 1000000) 1/2 3/4 90/100 95/100)
((0.95 53 951680.8) (0.9 38 901602.1) (0.75 20 756305.9) (0.5 9 527378.4))

Ce qui signifie que les 53 personnes les plus riches(sur les 500 de départ) possèdent à elles seules plus de 95% de la fortune totale du système, et ainsi de suite jusqu'au terme final qui dit que les 9 personnes possèdent plus de la moitié des richesses totales.

Si on annule *regulatory-advantage* on voit cet effet s'accentuer:

CL-USER> (let ((*regulatory-advantage* 0))
       (fortune-repartition (fortune-simulation 1000000) 1/2 3/4 90/100 95/100))
((0.95 18 955952.6) (0.9 14 916244.6) (0.75 8 763214.2) (0.5 4 537323.9))

et les seules 4 personnes les plus riches concentrent 50% des richesses totales.

En fait tu n'as pas besoin de faire une branche. Comme tu tires A et B au hasard, tu peux dire a priori que c'est toujours A qui paie B. Ça n'apporte rien de choisir à pile ou face si c'est A qui paie B ou vice-versa.

Bravo à toi! J'ajouterai une petit 5.:

1. Vérifier méthodiquement et humblement que toutes les hypothèses qu'on croit vraies le sont.

L'idée est d'avoir une démarche aussi scientifique que possible en construisant un énoncé de type “Étant donné que ceci, je fais cela, et m'attends à ça. Mais je vois autre chose.” et de procéder méthodiquement pour circonscrire de plus en plus l'incertitude pour finalement trouver ce qu'on croit et qui n'est pas vrai.

Ici les hypothèses sont, par ordre de complexité de vérification croissante:

• J'ai construit une ligne de commande valide. (Vérifier bout à bout chaque argument.)
• J'ai accès au réseau.
• Mon système peut résoudre les noms de domaines (cf. le message d'erreur que tu as mentionné).
• J'utilise bien le programme rsync que je crois (si plusieurs versions sont installées).
• J'utilise bien le programme ssh que je crois (idem).
• Je n'utilise pas une version de rsync qui a une bogue bien connue.

etc.

L'auto-baffage ne semble pas utile, toutes les erreurs sont évidentes lorsqu'on les a découvertes!

Il me retourne un laconique "ssh: Could not resolve hostname".

Même souci quand j’utilise l’adresse IP à la place du nom de domaine.

C'est peu probable que ssh ait un problème à résoudre … une adresse IP. Le mieux serait que tu partages les logs en entiers – en remplaçant les informations que tu veux protéger par des arguments génériques comme tu l'as fait.

Pour la présentation tu peux faire comme ça (triple tilde, regarde la syntaxe markdown dans les liens au bas de la page).

➜  ~ rsync -a -e ssh ./. user@192.168.0.1:/path/to/folder
ssh: connect to host 192.168.0.1 port 22: Connection refused
rsync: connection unexpectedly closed (0 bytes received so far) [sender]
rsync error: error in rsync protocol data stream (code 12) at …

Pour utiliser ton .ssh/config dans les scripts il n'y a rien de spécial à faire. Tu peux utiliser ssh-add pour ajouter les clefs nécessaires au ssh-agent avant l'exécution du script. Tu peux aussi utiliser une configuration alternative (pour le script, différente de celle pour l'utilisateur).

Sur Wikipédia, je lis :

Je pensais à des raisons mathématiques. :-)

Tu tournes simplement la conséquence à l'envers

J'essaie surtout de comprendre ce que tu essaies de dire. Pas pourquoi c'est vrai ou non juste le contenu de ta phrase. À mes yeux ce n'est pas très clair et je me suis dit qu'essayer de reformuler serait plus urbain que de te demander de reformuler.

D'abord merci, d'avoir pris le temps de bien détailler.

Donc, si on prend un décès au hasard dans la population dans l'année, il a 4% de chances d'être dû au covid. Donc, en particulier, si dans une famille il y a un décès dans l'année, il y a 4% de chances qu'il soit dû au covid.

Bon alors là je te suis, mais après moins:

Donc pour que dans chaque famille il y ait en moyenne un décès lié au covid dans l'année, il faut qu'il y en ait eu 100/4 = 25.

Je ne sais pas trop ce que tu veux dire par “il y ait en moyenne” mais j'ai l'impression que tu dis un truc du genre “Si toute famille perdait 25 personnes alors la moyenne du nombre de décès liés au covid dans chaque famille serait d'environ 1.” – ce qui est assez loin de ta formulation. Alors c'est numériquement vrai (plutôt 26) mais as tu une idée d'une raison plus sérieuse?

Mais par contre c'est une affirmation bien différente de ton affirmation antérieure de type “Si une famille a perdu une personne du covid alors elle a certainement perdu 10 (ou 25) autres personnes.” – qui fait très “loi des petits nombres”.

(setf *random-state* (make-random-state t))

(defparameter *simulation-size* (* 1000 1000))

(defun bernoulli (p)
  "Bernoulli trial with probabilty P of success."
  (<= (random 1.0) p))

(defun bernoulli-success (p n)
  "Number of successes in a series of N Bernoulli trials with parameter P."
  (loop for i from 1 to n
    for ax = 0 then (if (bernoulli p) (1+ ax) ax)
    finally (return ax)))

(defun average-bernoulli-success (p n)
  (declare (optimize (speed 3)))
  (loop for i from 1 to *simulation-size*
    for ax = 0.0 then (+ ax (bernoulli-success p n))
    finally (return (/ ax *simulation-size*))))

CL-USER> (average-bernoulli-success 0.04 25)
0.959485
CL-USER> (average-bernoulli-success 0.04 26)
0.9996348
CL-USER> (average-bernoulli-success 0.04 27)
1.0398979

Ils doivent se trouver dans une zone particulièrement touchée […]

Il y a sûrement de cela. Ils habitent dans des grands centres urbains (Pune, Mumbai, Bangalore et Chennai, faisant respectivement 3, 8, 12 et 7 millions d'habitants) où on peut raisonnablement penser que le virus circule plus que dans les campagnes et dont l'atmosphère est gravement polluée. (En partant du principe qu'ils vivent près de leurs proches.)

si chaque famille a perdu un proche du fait du covid, ils ont perdu 10 proches du fait d'autres causes également.

Ça m'intéresserait que tu détailles un peu ton raisonnement parceque j'ai fait de beaux accents circonflexes avec mes sourcils en lisant ça. (Je suis plutôt sceptique.) :-)

D’après moi, il doit aussi être possible d’en trouver qui vont te dire qu’il y a plus de chances qu’un covid modifie ton ADN que le vaccin !

D'aucuns vont même jusqu'à dire que les virus s'insèrent dans l'ADN des cellules de l'hôte pour profiter de leurs capacités reproductives!

Tu te souviens de la dernière fois où quelqu'un t'a convaincu par son outrance? Où tu t'es dit “Cette personne exagère vraiment bien, elle doit avoir raison!”

Lorsqu'il s'agit de convaincre les autres, l'outrance est bien à sa place dans la liste des techniques qui ne marchent pas à côté de l'énervement et de la menace.

L'Inde a été terriblement touchée. Dans mon projet on a une quarantaine de collègues en Inde et tous ont perdu au moins un proche (parents, cousins, oncle et tante) dans l'épisode auquel tu fais référence.

Dans le petit fil de discussion qui nous préoccupe on veut juste rappeler qu'aucun train ne va emmener personne dans dans un camp où on serait humilié, brimé, maltraité, affamé, torturé, empoisonné, réduit à voler enfants et mourants pour sa propre survie, contraint à enterrer soi même les restes de ses amis et parents? (Ça c'est pour la partie mesure.)

Du reste on ne peut pas complètement exclure que des membres des familles de déportés participent à LinuxFR. (Ça c'est la partie empathie.)

En revanche dire “Oui c'est vrai j'ai exagéré” n'a jamais fait de mal à personne – on dit parfois que ça fait mal à la bouche mais c'est une légende.

Oui c'est bien ce que je voulais dire, merci d'avoir éclairci la situation!

Je pense que si tu avais vécu ces situations en conditions réelles tu réaliserais à quel point ton parallèle est à vomir.

Un peu d'empathie et de mesure suffiraient…

Le rédacteur de la dépèche a-t’il réalisé que l’État dispose déjà d’un cloud privé monté entièrement en Open Source (Linux, OpenStack, …) ?

Où est-ce que les curieux de mon genre pourraient en apprendre plus à ce sujet?