Les systèmes réducteurs

@ Cantador
Plus têtu que Cantador, tu meurs!!! Il fallait que je te secoue un peu. tu as de tels préjugés! Mais je te rassure je suis au moins aussi têtu que toi!

Je respecte ton droit de ne pas me répondre, mais alors ne t'étonne pas que tu ne trouves pas de solution! Vois-tu la question  est : est-ce que tu  es suffisamment  motivé pour la trouver?  Je  peux t'affirmer qu'on en était plus très loin. Bien que je ne me suis pas penché sur l'alinéa  0.2  qui pourrait modifier la suite du raisonnement. Puisqu'effectivement, je ne sais toujours pas à quoi, elle correspond.

La première chose à faire dans une formalisation mathématique, c'est de quantifier les variables (on les a), de les définir aussi précisément que possible (ça n'est pas encore clair) et leurs limites possibles (primordial également. Ensuite on articule  les varaibles entre elles par des énoncés  précis et on démontre  les lois trouver.  Ensuite, la formule trouvée, la programmation devient facile...

Là ou tu coinces, c'est que tu es persuadé d'avoir la solution juste. On ne peux rien apprendre à celui qui pense avoir raison. Si tu n'envisages pas d'avoir tord, tu ne progressera pas! Mais si tu joue le jeu, alors au moins tu sauras pourquoi tu es ou pas d'accord avec l'autre. Le pb, c'est qu'on n'est pas parvenu à la formalisation même des données du Pb. Dans ce cas, tu peux rester si tu veux avec ton système de croyance, ça ne m'empêchera pas de dormir.

Quant à mes compétences, je te rassure, j'ai travaillé le domaine des statistiques à un bon niveau et j'ai utilisé dans mon travail SPSS 10.0 un logiciel professionnel d'analyses statistiques. je programme également les équations sphériques du déplacement des planètes (par plaisir) dans le ciel.

Ton problème est franchement très simple. Mais comme tu l'as dit, ça dépasse peut-être le cadre mathématique, mais alors au moins, tu sauras à quoi t'en tenir. Est-ce, l'agrégé qui t'as dis qu'il fallait un gros ordinateur pour ce genre de pb? Ce qui signifierait que la solution ne relève pas d'un formalisme mathématique de puriste, mais d'analyses de données à postériori.

Avec ce que tu m'as donné, je n'ai fait que l'envisager. Si c'était le cas, tu n'aurais plus qu'a programmer des grilles prédéfinies comme celles que tu nous a donné. Mais je n'en suis pas convaincu encore! Il y a une possibilité de trouver une formule simple. c'est ma conviction actuelle. 

tu vois, je suis non seulement têtu, mais noeud-noeud, alors faut bien m'expliquer! Mais si t'as pas envie, je respecte, ce sont les règles même de ce forum.

Bien à toi

@ Patisalex
Je n'ai pas le temps de me pencher sur ce que tu dis pour l'instant. Mais donne ta méthode ou ton lien internet. si ça peut méclairer au niveau du problème, ça évitera à cantador de s'arracher les cheveux.

Jean_jean

"Attention Cantador, c'est en toute amitié que je te dis de ne pas croire à ce qu'affirment les gens et les auteurs de livres, s'ils ne prouvent pas ce qu'ils disent ou ne citent pas leurs références.
J'ai passé un temps considérable dans ma vie à découvrir des erreurs dans les livres. Surtout à notre époque,ou tout va très vite et des gens sans scrupules trouvent des créneaux en profitant de la crédulité des gens.
Qu'ils soient vieux ou jeunes, la majorité des gens ne veulent pas de la vérité qui dérangent leur confort et leurs croyances. C'est plus facile de suivre le troupeau et de juger selon les apparences, les conventions ou ce qu'affirment les autres."

les préjugés, c'est toi jean_jean...

Moi, je pose une question simple sur le forum, mais je n'oblige personne à y répondre.. et surtout pas en particulier ceux qui ne connaissent même pas les systèmes réducteurs..(le nom était dans le titre)
Ce n'est pas le niveau mathématique qui est en cause, c'est simplement le fait que tu ne connais pas les systèmes réducteurs et qu'apparemment tu n'est pas joueur !
Alors comment veux-tu avec ces deux handicaps faire avancer le schmilblic !

La preuve est que Patisalex qui s'intéresse à la chose lui il a compris tout de suite de quoi on discutait (il a même founi de la doc)et je n'ai pas besoin de lui faire une grand messe pour lui expliquer..
et je n'ai pas dit que j'ai trouvé la solution..enfin..je me débrouille néanmoins..
et je continue à chercher..c'est tellement passionnant de chercher..

Mais au fait jean_jean, c'est quoi pour toi la définition d'une planète et à ton avis c'est quoi la matière sombre ?


cantador

Bonjour, Pour Jean_Jean : Explications plus complètes sur les systèmes reducteurs : http://caploto.free.fr/Base_de_connaissances-Cap-Loto/Accueil_Base-Connaissances-Cap-Loto.html Un exemple mais sans trop d'explications : http://chrisferon.free.fr/EuroMillions-Record.htm Exemple de reductions avec visualisation : http://lotopasq.ifrance.com/lotopasq/reduction.html http://www.software-ds.com/martingale/martingale.php A+ Patisalex

@ Patisalex

Merci pour ces liens intéressants. Je n'étais donc complètement N½ud-n½ud et j'avais compris en partie ce qu'était un système réducteur. Mais sur un plan théorique, cela ne se passe pas du tout comme l'a exposé Cantador. Normal ! C'est toute la difficulté du formalisme mathématique. Les apparences de simplicité sont trompeuses.

Je viens donc de relire ton post avec les regroupements par 2 des numéros. C'est un tout autre problème que vous exposez pour parvenir à 4 grilles car il n'y a plus équiprobabilité. La solution que je vous propose est juste dans son formalisme car elle respecte l'équiprobabilité. C'est à dire que l'événement élémentaire E₁ qui consiste à choisir 1 n° dans la sélection de 8 pour une grille de 6 a la même probabilité de sortie pour chacun des numéros que ce soit le n°1 ou le n°2 et ce sur l'ensemble des 28 grilles.

                   C₁¹ x C₇⁵

P(E₁) =  ----------- = 75%. (-- > 21 grilles possèdent un n° particulier)

                              C₈⁶

Par contre, dans la grille que vous proposez, c'est comme si vous n'aviez que 4 numéros au lieu de 8. Dans ce cas, vous arrivez à 4 grilles :

C₄³ = 4 (6n° = 3x2 et 8n° = 4x2) qui consiste à permuter les couples indissociables de numéros pris 2 à 2:

1	2	3
1	2	4
1	3	4
2	3	4

 

7-8

5-6

3-4

1-2

 

 

Mais en fait, cette réduction est abusive sur un plan mathématique, car les numéros des couples sont des entités indépendantes et réelles dans N. On a déjà calculé la Probabilité de sortir 1 n° de N. Voyons maintenant qu'elle est la probabilité d'en sortir 2.

                   C₁¹ x C₁¹xC₆⁴

P(E₂) =  ---------------- = 53,6%. (-->15 grilles possèdent un couple particulier)

                                  C₈⁶

P(E₁) <> P(E₂) . Par conséquent, lorsque vous avez un nombre pair  de couples (Grille = 3 couples), il y a équiprobabilité, mais plus lorsque vous êtes dans un nb impair qui va mixer les évènements  Choisir le n°1 ou le n° 2 est équiprobable  (la même probabilité de sortir pour des évènements non homogènes E₁ E₂ par exemple.

Donc en ésumé, les formules que je vous ai donné sont justes dans le cadre des 4 énoncés donnés pour un Tirage sans le complémentaire que l'on ne prend pas en compte dans un but de simplification.

           Card(P_bn/P_g) = C_Pg^Pbn x C_{N - Pg}^{Pg - Pbn}

Si vous voulez au moins 5 bons numéros, cela veut dire que sur les 28 grilles, il y aura  12 grilles comprenant 5 n° et 1 grille qui comprend les 6 n° gagnants. Cela s'écrit comme étant la réunion de deux évènements élémentaires et certains :

Card(solutions) = Card(E₅)+Card(E₆) = C₆⁶ x C₂⁰ + C₆⁵ x C₂¹ ;

Tout cela bien sûr, dans l'Hypothèse sûr du SI « Les 6 n° gagnants sont parmi les 8 choisis).

Pour N = 8 et Pg = 6
Système 6/6	C66 x C20	= 1
Système 5/6	C65 x C21	= 12
Système 4/6	C64 x C22	= 15
Système 3/6	C63 x C23 (3>2 impossible)	= 0

En plus du premier SI (6 n° gagnants sur 8), vous avez une perte d'environ 40% supplémentaire à cause du 2^ème SI qui considère ces couples d'équiprobabilité. C'est pas gagné !

Et ça, les sites vendeurs de logiciel n'en parlent pas. Apparement, ils n'attaquent pas la solution par la théorie (qui relève à mon avis du formalisme de la  Stochastique) assez complexe car il faut introduire la notion de résidu ou d'intervalle de confiance. Les formules deviennent ardues. Mais ça n'est pas impossible. L'institut Européen de la statistique qui analysent les jeux du hasard l'ont fait, mais c'est confidentiel. Ces logiciels travaillent sur l'analyse des tirages antérieurs.

Bon je n'y reviens plus ! Sauf si vous m'apportez du nouveau pour mes neurones.

Jean_Jean

 

Bon, la grilledes couples est mal passée dans le post, mais je pense que vous aviiez compris cette solution que vous défendez depuis ledébut
Jean_Jean

Tes calculs sont parfaitement exacts Jean_Jean....
Ces résultats, je les connaissais déjà.

Le problème que tu as résolu n'est pas la solution à la question que j'ai posée sur le forum...

cantador

Salut à tous !

Histoire de m'insérer dans ce débat je m'intéresse depuis peu à ces fameux systèmes réducteurs. Alors question formalisation mathématique je ne suis pas trop au top mais malgrès tout je crois avoir réussi à pondre un petit prog Delphi qui permet de calculer des systèmes réducteurs.
Ok c'est assez sommaire pour l'instant mais le programme ne demande qu'à évoluer. Pour le moment il lui faut environ une à deux heures pour calculer un système réducteur de 14 chiffres pour un tirage de 6 numéros (genre le loto).
Cependant, il ne demande qu'à évoluer.

Heu par contre j'ai pas encore trouvé comment uploader du code sur ce site. Donc pour le moment je vous le livre brut de béton (armé).  


program Reducteur;

{$APPTYPE CONSOLE}

uses
  SysUtils;

{
  Objectif : programme de calcul de systèmes réducteurs
  Le programme calcule le nombre de combinaisons nécessaires pour
  être sûr d'obtenir n numéros parmis m tirés sur une sélection de p numéros
}

function Combinaison(AValeurMax : Integer; ASelection : Integer) : Integer;
var
  i : Integer;
  p : Integer;
  r : Int64;
begin
  r := 1;
  p := AValeurMax;
  for i := 0 to Pred(ASelection) do begin
    r := p * r;
    Dec(p);
  end;
  p := ASelection;
  for i := 0 to Pred(ASelection) do begin
    r := r div p;
    Dec(p);
  end;
  Result := r;
end;

var
  i : integer;
  j,k,l,m,n,o,p : Integer;
  n1, n2, n3, n4, n5, n6 : Integer;
  nb_numeros_tires : Integer;
  nb_numeros_selectionnes : Integer;
  nb_numeros_objectif : Integer;
  nb_numeros_max : Integer;
  combinaisons : array of array[0..5] of byte;
  nb_combinaisons : Integer;
  selection : array of Integer;
  nb_combinaisons_selectionnee : Integer;
  nb_numero_communs : Integer;
  satisfaisant: Boolean;
  found : Boolean;
begin
  nb_numeros_tires := 6;     // on part de cette base pour le loto
  nb_numeros_max := 49;
  nb_numeros_objectif := 3;
//  for nb_numeros_objectif := 3 to nb_numeros_tires do begin
    for nb_numeros_selectionnes := nb_numeros_tires to nb_numeros_max do begin
      // calcul du nombre de combinaisons possibles
      nb_combinaisons := Combinaison(nb_numeros_selectionnes, nb_numeros_tires);
      SetLength(combinaisons, nb_combinaisons);
      System.Writeln(Format('Selection : %d '#7' Combinaisons : %d', [nb_numeros_selectionnes, nb_combinaisons]));

      // remplissage du tableau
      combinaisons[0][0] := 1;
      combinaisons[0][1] := 2;
      combinaisons[0][2] := 3;
      combinaisons[0][3] := 4;
      combinaisons[0][4] := 5;
      combinaisons[0][5] := 6;
      if High(Combinaisons) > 0 then begin
        for i := 1 to High(Combinaisons) do begin
          for j := 0 to High(Combinaisons[i]) do begin
            Combinaisons[i][j] := Combinaisons[i-1][j];
          end;
          j := High(Combinaisons[i]);
          Inc(Combinaisons[i][j]);
          while Combinaisons[i][j] > (nb_numeros_selectionnes + j - High(Combinaisons[i])) do begin
            Inc(Combinaisons[i][j-1]);
            Dec(j);
          end;
          for j := 1 to High(Combinaisons[i]) do begin
            if Combinaisons[i][j] > (nb_numeros_selectionnes + j - High(Combinaisons[i])) then begin
              Combinaisons[i][j] := Combinaisons[i][j-1] + 1;
            end;
          end;
        end;
      end;

      // Selection du nombre de combinaisons
      // On Selectionne de 1 à nb_combinaisons

      for i := 1 to nb_combinaisons do begin
        SetLength(selection, i);
        // Selection initiale de combinaisons
        for j := 0 to Pred(i) do begin
          selection[j] := j;
        end;

        satisfaisant := false;
        // On teste toutes les combinaisons possibles de combinaisons
        for j := 0 to Pred(Combinaison(nb_combinaisons, i)) do begin
          p := High(selection);
          while selection[p] > High(Combinaisons) + p - High(Selection) do begin
            Inc(selection[p-1]);
            dec(p);
          end;
          for p := 1 to High(selection) do begin
            if selection[p] > High(Combinaisons) + p - High(Selection) then begin
              selection[p] := selection[p-1] + 1;
            end;
          end;

          // Test effectue pour chacune des combinaisons possibles
          for k := 0 to High(Combinaisons) do begin

            // On cherche si au moins un de nos combinaisons
            // statisfait la contrainte
            found := False;
            for l := 0 to High(selection) do begin
              nb_numero_communs := 0;
              for m := 0 to High(Combinaisons[k]) do begin
                for n := 0 to High(Combinaisons[selection[l]]) do begin
                  if Combinaisons[k][m] = Combinaisons[selection[l]][n] then begin
                    Inc(nb_numero_communs);
                    if nb_numero_communs = nb_numeros_objectif then break;
                  end;
                end;
                if nb_numero_communs = nb_numeros_objectif then break;
              end;
              found := nb_numero_communs = nb_numeros_objectif;
              if found then break;
            end;
            if not found then begin
              satisfaisant := False;
              break;
            end else begin
              satisfaisant := True;
            end;
          end;

          // On a testé notre ensemble de combinaisons, si ce dernier n'est pas
          // satisfaisant, on en change
          if not satisfaisant then begin
            Inc(Selection[High(Selection)]);
          end else begin
            Writeln(Format('%d combinaisons necessaires', [Length(Selection)]));
            for k := 0 to High(selection) do begin
              for l := 0 to High(Combinaisons[selection[k]]) do begin
                write(Format('%.2d ', [combinaisons[selection[k]][l]]));
              end;
              writeln('');
            end;
            break;
          end;
        end;
        if satisfaisant then break;
      end;

    end;
//  end;
  system.Readln;

 

end.

Merci despeludo pour la diffusion de ce soft en mode console.
J'examine le code...
@+

cantador

despeludo ,

J'ai regardé attentivement le code.
La logique est bonne mais il y a énormément de boucles et  les temps de traitement sont affreusement longs (certains cas demandent plusieurs heures..) et rendent
le programme très difficilement exploitable notamment si on veut créer un système en introduisant des taux de garantie.

Mais les résulats sont corrects et répondent à mon souci.

Peut-être une autre approche mathématique ?

A+

cantador

Oui je sais et c'est tout le problème : trouver des astuces de codes permettant d'accélérer le traitement mais également confronter les résultats à l'ensemble des tirages possibles.
Je pense qu'une première optimisation pourrait simplement consister à dire que si pour une sélection de n numéros le système réduit est constitué de p grilles, alors pour n+1 numéro le système réduit sera constitué d'au moins p grilles égalements. Je ne pense prendre de grands risques en proposant ce postulat. C'est pas grand chose à modifier dans le programme mais je crois que cela peut permettre d'éconimiser pas mal de temps.
Maintenant, il ne faut réver non plus, si tu regardes bien sur le net tu verra que certains ont créés des clusters de calculs de systèmes réduits.
Autre axe d'amélioration du programme de base :
A priori, pour une sélection de n numéros on peut trouver plusieurs systèmes réduits. Exemple pour une sélection de 7 chiffre le système réduit 1-2-3-4-5-6 fonctionne mais également 2-3-4-5-6-7 (il doit y en avoir 7 au total).
Bon là c'est un cas simple mais pour des systèmes plus complexe je me demande si la couverture de combinaisons est identique. Je veux dire par là que bien sûr on est sûr d'avoir au moins 3 numéros gagnants mais qu'en est-il des combinaions de 4 5 voire 6 numéros.
6 numéros c'est facile, on en couvre autant que l'on sélectionne de grilles. Mais couvre-t-on autant de de combinaisons de 3 et 4 chiffres dans chaque système réduit ?
Tu noteras que le programme proposé ne permet que de trouver un seul système réduit. (et c'est déjà bien assez long comme ça).