Newsgroup: it.hobby.enigmi
Titolo: Gino e Gina a braccetto [lunghina]

ciascuna delle prime tre terne e 2 nell'ultima terna).
[cut]
Si tratta di esprimere nel miglior modo possibile la distribuzione delle
varie terne tramite una sequenza iniziale dichiarativa (questo approccio al
problema ricorda molto da vicino lo studio dei sistemi di licitazione nel
gioco del bridge).
Ho provato a ragionare su questo bellissimo sistema con l'obiettivo minimo
del 13.
Consideriamo le possibili combinazioni di 0-1 errori nei primi 4 bit.
1) x x x x
2) E x x x
3) x E x x
4) x x E x
5) x x x E
Suddividiamo poi le 8 terne in 4 tipologie, a seconda delle posizioni della
loro dominante:
TTT/CCC  ---> omogenee
TTC/CCT  ---> sinistre
TCT/CTC ----> laterali
CTT/TCC ----> destre
A questo punto la sequenza 1 (nessun errore) dovrà essere utilizzata da Gina
in presenza di 1 o più terne 'omogenee'.
In questo caso Gino non dovrà far altro che puntare tre volte testa o tre
volte croce per ciascuna terna, senza variare alcunchè. Con 1 terna omogenea
si totalizzano 13 punti (3 errori nelle 3 terne non omogenee) mentre con 4
terne omogenee si totalizza il massimo di 16 punti.
Qualora non siano presenti terne omogenee, ci sarà oggettivamente una
tipologia, tra 'sinistre', 'laterali' e 'destre', presente almeno due volte
su quattro.
In questi casi Gina utilizza le combinazioni ad un errore.
Con almeno 2 terne 'sinistre' Gina utilizza la sequenza 2. Gino saprà che
per tutte e quattro le terne dovrà cambiare l'ultima scommessa, a meno che
non incappi in una terna laterale o destra, nel qual caso dovrà regolarsi
aggiustando il tiro.
Facciamo un esempio. La colonna vincente vista da Gina è la seguente:
T C C C / T T C / C T C / C C T / T C C
Non vi sono terne omogenee e vi è una predominanza di 'sinistre' (2 su
quattro). Gina scriverà:
C C C C T C C C
Dopo i primi 4 lanci Gino constaterà l'errore al primo posto (sequenza 2) e
si appresterà dunque a giocare 4 sinistre.
Nella prima terna (sinistra) realizza 3 su 3. Nella seconda (laterale), al
secondo lancio, incappa nell'errore. Quindi al terzo lancio si correggerà e
ribadirà la C, che è la dominante di quella terna, totalizzando 2 su 3.
Nella terza terna (sinistra) realizza ancora 3 su 3 e nella quarta,
incappando al primo lancio in un errore, ribadirà negli ultimi 2 la C, che è
la dominante, totalizzando 2 su 3.
Un discorso analogo vale per la predominanza di terne laterali (sequenza 3)
o destre (sequenza 4) sulle quattro terne.
Quindi con 2 terne di uno stesso tipo si realizzano sempre 13 punti. Con 3
terne dello stesso tipo 14 punti, mentre con 4 dello stesso tipo 15 punti
(bisogna sempre contare l'errore trasmesso da Gina).
Calcolando le varie disposizioni dei 4 tipi di terne sono giunto dunque ai
seguenti calcoli di vincita:
13 = 41472 = 63.28 %
14 = 19968 = 30.46 %
15 = 3840 = 5.85 %
16 = 256 = 0.39 %
con vincita media 13.43, che non è certo alto, ma si consideri che non viene
utilizzata la sequenza 5, la quale potrebbe contribuire a migliorare la
previsione sulle terne.
Se ad esempio la sequenza 5 significasse (butto lì) 'prime 3 terne sinistre,
l'ultima destra', aumenterebbero le combinazioni di vincita dei 15 punti a
discapito di quelle da 13. Però questo tipo di informazione che direi 'a
precisione massima', (perchè identifica nei loro posti esatti le tipologie
di terne) non mi soddisfa molto, in quanto non omogenea con quelle
'dinamiche' delle sequenze ad 1 errore.
Per aggiungere le informazioni 'a precisione massima' si possono utilizzare
le 6 sequenze a 2 errori, ad esempio:
6) E E x x  ---> S, S, L, L
7) E x E x  ---> S, S, D, D
8) E x x E  ---> L, L, D, D
9) x E E x  ---> L, L, S, S
10) x E x E  ---> D, D, S, S
11) x x E E  ---> D, D, L, L
Le sequenze a 3 errori sono inutili, in quanto totalizzano, anche se a
precisione massima, comunque 13 punti.
Le sequenze a 2 errori aumentano le combinazioni di 14 punti sempre a
discapito di quelle da 13.
Per concludere, tenendo buona la sequenza 5 con S, S, S, D (sperando di
capire meglio come utilizzarla) e inserendo le sequenze a 2 errori sono
giunto ai seguenti risultati:
13 = 39680= 60.54 %
14 = 21504= 32.81 %
15 = 4096= 6.25 %
16 = 256 = 0.39 %
con vincita media 13.4636. In particolare le vincite di prima e seconda
categoria sono uguali a quelle del tririduttore di Nino Aspesi, quindi vuol
dire che il sistema funziona bene, anche se sono convinto che esistano altre
tecniche legate a questo approccio più favorevoli (in termini di vincita
media) senz'altro.
Un saluto a tutti ancora
Francesco

 scovato la mail di Paolo Licheri, che però non ha avuto seguito,
Finalmente! Erano giorni che mi arrovellavo per cercare di sviluppare
quell'idea, ma non avevo trovato niente che si avvicinasse ai risultati
ottenuti con i riduttori.
Un'altra idea, sempre sullo stesso filone, era:
I primi 7 bit indicano i primi 7 lanci.
L'ottavo bit indica il segno predominante nei rimanenti 9 lanci.
Se in questi nove la distribuzione dei segni è diversa da 5-4 ho
garantito almeno il tredici.
Se la distribuzione dei nove lanci è 5-4 ho il dodici. Ma chissà se,
sfruttando gli errori nei primi 7, si può ottenere qualcosa di buono.
ciao
paolo

Questo è uno dei biriduttori di 9 doppie, a garanzia di 7 su 9.
Si tratta di 16 colonne suddivisibili in 8 gruppi, dove ogni gruppo contiene
2 colonne esattamente speculari.
1 -->(0,8)
2 -->(1,11)
3 -->(2,10)
4 -->(3,9)
5 -->(4,13)
6 -->(5,12)
7 -->(6,15)
8 -->(7,14)
Dato che nei primi 7 bit Gina può trasmettere fino a 8 messaggi diversi (con
0-1 errori), chiaramente potrà indicare il gruppo da giocare per i rimanenti
9 lanci, mentre l'ottavo bit, che come dici tu determina il segno dominante,
permette di scegliere quale colonna delle due del gruppo indicato
utilizzare.
Ciao

 con vincita media 13.43,
ciao
paolo

 tririduttore indicatagli da Gina.
Un altro metodo, molto più semplice. che si avvale di accordi "a priori"
(senza sfruttare le informazioni rilevabili dall'esito dei lanci
precedenti),
e che comunque assicura sempre almeno il 13 è:
- primi 2 bit: numerazione dei classici riduttori di 3 doppie:
00 = CCC o TTT ;  10 = CTT  o  TCC ;  01 = TCT  o  CTC ;  11 = TTC  o  CCT
- terzo bit  : esito del primo lancio
- dal 4° all' 8° bit : indicazione del segno prevalente dei lanci successivi
(presi 3 alla volta, dal 2° al 16°)
Nota: in certi casi, per garantire 2 punti validi occorre dare
l'informazione
errata sul segno, indicando non quello prevalente, ma il minoritario.
Es.  sia  C CCT TTC CTC TTT TCC   prevale il riduttore 11 presente 2 volte
 sarà:  11 C C T T T T    e non  11 C T C T C
E' evidente che, essendo 4 i riduttori di 3 doppie, ce ne sarà uno che
uscirà
almeno 2 volte (quello evidenziato nei primi 2 bit). Quindi, al minimo,
1+3+3+2+2+2 = 13
E come questo, esistono molti altri metodi a garanzia di vincita minima del
13.
Ciao, Nino


Ovviamente:
    ......                  e non  11 C C T C T C
Nino

 Aspesi il 28 Marzo
[cut]
Bellissima.
Per caso hai calcolato la vincita media?
ciao
paolo

 wrote in message
W7vgc.69578$hc5.3...@news3.tin.it...

Ciao ancora,
per calcolare la vincita media dovrei scrivere un programmino che calcoli le
effettive possibilità del biriduttore in questione.
Mi sembra che non sia perfetto, nel senso che credo realizzi più vincite di
2a e 3a categoria (ogni colonna dovrebbe coprire infatti 9*8/2 cioè 36
colonne dell'integrale per n-2, ma 36*16=576 è superiore alle stesse 512
colonne integrali che si coprono).
In questo senso una mano potrebbe darcela lo stesso Nino, che vedo ci segue
nel 3d, e che con questo biriduttore ha calcolato già tempo fa una vincita
media.
Ad ogni buon conto, se non mi sbaglio, la percentuale di una vincita di
prima categoria mi sembra piuttosto alta.
La vincita di 1a cat. si ottiene in una sequenza di 7 bit senza errori, che
richiama uno degli 8 gruppi.
Quindi la probabilità del 16 è uguale alla probabilità di azzeccare la
colonna del biriduttore di 9 doppie esatta, cioè 16/512 che corrisponde al
3,125%.
Possibile?


Anche questa soluzione è davvero molto, molto bella.
Come ho già scritto or ora a Paolo, si potrebbe sfruttare anche nel sistema
da lui proposto e da me ripreso.
Saluti
Francesco

 informazione aggiuntiva che la quinta sequenza avrebbe potuto dare
E' vero, effettivamente il bug c'è.......
Comunque ancora complimenti per aver già risolto in maniera brillante.
Mi sembra inoltre che le osservazioni fatte da Nino (vedi la sua proposta di
oggi) possano essere utili anche per questo genere di tentativo. Lui propone
che in alcuni casi Gina passi non le dominanti delle terne bensì il segno
opposto, a parità di tipologia di terne.
Ad esempio una terna sinistra TTC (T dominante) posta con 3 altre terne
laterali, potrebbe essere passata da Gina anch'essa come laterale a C
dominante.
Questo potrebbe voler dire poter passare un'unica tipologia di terna, oppure
in altri casi un'unica lettera dominante, (oppure entrambe le cose). Il che
mi sembra aumenti ancora di più il ventaglio di possibilità.
Francesco


No! Grande ca..ata.
I 7 bit invocano un solo gruppo di due colonne, quindi la probabilità è
2/512, ovvero i soliti 256. Per cui, se non sbaglio ancora:
13= 44544= 67.968
14=18688= 28.363
15=2048= 3.125
16=256 = 0.3906
Vincita media = 13.33 ca


Facendo i calcoli sul biridotto di 9D:
2 colonne realizzano 16 punti = 0,3906%
32 colonne (18+14)   15 punti = 6,25%
170 colonne (44+126) 14 punti = 33,20313%
308 colonne (14*22)  13 punti = 60,15625%
Per cui la vincita media risulta pari a 13,46875
che è d'altronde il valore che si realizza abbinando
un ridotto di 7D (i primi 7 bit, con le condizioni
di errore imposto, realizzano una volta 7 e 7 volte
6 punti, come il ridotto di 16 colonne)
ad un biridotto di 9D.
Ciao, Nino

 [...]
Anch'io sono rimasto piuttosto ossessionato, rileggendo il testo
originale del problema dei Gini, dal fatto che si potesse trarre un
surplus di informazione dal confronto tra il codice e la realta'
che man mano appare al ricevitore.
Penso pero' che sbagliare apposta un bit sia troppo penalizzante
e che bisognerebbe cercare un metodo piu' gratuito, anche se
statistico. Per restare nella similitudine del bridge, mi torna alla
mente quando, nel gioco della carta, dovendo giocare per forza
una scartina, spesso (anche se non sempre) posso scegliere di
scartare una carta pari oppure una dispari per dare un'informazione
al socio. E' un'informazione solo statistica, ma e' assolutamente
gratis. Vediamo se posso fare qualche cosa di analogo.
Premetto che non ho superato la vincita media di 13.601 di Giorgio,
ma descrivo ugualmente il metodo nella speranza che sia perfettibile
e che qualcuno lo perfezioni o trovi altre idee analoghe.
Prima di tutto ho cercato di costruire un sistema ridotto da 256
colonne per 15 bit. Al meglio ho ottenuto questo risultato:
*****************************
Numero bit = 15
Numero colonne = 256
Vincita media = 12.859375
Punti/Colonne
 15:    256
 14:    3840
 13:    19712
 12:    8960
 11:    0
Numero ridondanti = 14448
*****************************
(e gia' qua qualcuno potrebbe fare meglio)
Le "ridondanti" sono tutte quelle colonne che possono
indifferentemente essere codificate dalla Gina con due
diversi byte del ridotto, indicando entrambi una parola
ugualmente distante dalla desiderata. Esempio:
111001001001110
puo' essere codificato indifferentemente da uno di questi:
011001101011110
111000001000111
entrambi diversi di 3 bit: entrambi realizzano 12 punti.
Quando il Gino vede l'esito del 15.o sorteggio egli sa quale
dei due codici e' stato intenzionalmente usato dalla Gina:
se la Gina ha usato quello superiore, conviene che il
sedicesimo bit vale uno, e viceversa.
Dai calcoli che ho fatto (verificare) disponiamo di questa
informazione in 14448 casi su 32768 pari al 44%, cioe'
nel 44% dei casi siamo in grado di predire il sedicesimo
bit, nel 56% rimanente dobbiamo tirare ad indovinare: il
risultato complessivo sara' che lo azzeccheremo il 72%
delle volte, portando a quasi 13.58 la vincita media sui
sedici bit.  S.E.&.O.
Metto in fondo il sistema ridotto che ho usato per permettere
eventuali verifiche e/o migliorie.
Alla prossima!!!  ((^__^))'
Livio
000000000000000
111110000000000
110001110000000
001111110000000
101001001100000
010111001100000
011000111100000
100110111100000
010100101010000
101010101010000
100101011010000
011011011010000
111101100110000
000011100110000
001100010110000
110010010110000
011001000001100
100111000001100
101000110001100
010110110001100
110000001101100
001110001101100
000001111101100
111111111101100
001101101011100
110011101011100
111100011011100
000010011011100
100100100111100
011010100111100
010101010111100
101011010111100
110100100001010
001010100001010
000101010001010
111011010001010
011101101101010
100011101101010
101100011101010
010010011101010
100000001011010
011110001011010
010001111011010
101111111011010
001001000111010
110111000111010
111000110111010
000110110111010
101101100000110
010011100000110
011100010000110
100010010000110
000100101100110
111010101100110
110101011100110
001011011100110
111001001010110
000111001010110
001000111010110
110110111010110
010000000110110
101110000110110
100001110110110
011111110110110
110101001001001
001011001001001
000100111001001
111010111001001
011100000101001
100010000101001
101101110101001
010011110101001
100001100011001
011111100011001
010000010011001
101110010011001
001000101111001
110110101111001
111001011111001
000111011111001
101100001000101
010010001000101
011101111000101
100011111000101
000101000100101
111011000100101
110100110100101
001010110100101
111000100010101
000110100010101
001001010010101
110111010010101
010001101110101
101111101110101
100000011110101
011110011110101
000001101000011
111111101000011
110000011000011
001110011000011
101000100100011
010110100100011
011001010100011
100111010100011
010101000010011
101011000010011
100100110010011
011010110010011
111100001110011
000010001110011
001101111110011
110011111110011
011000101001111
100110101001111
101001011001111
010111011001111
110001100101111
001111100101111
000000010101111
111110010101111
001100000011111
110010000011111
111101110011111
000011110011111
100101001111111
011011001111111
010100111111111
101010111111111
101100101001000
001010010101000
110111110011000
010001001111000
011011111001110
111101000101110
000000100011110
100110011111110
011001100000001
111111011100001
000010111010001
100100000110001
101110110000111
001000001100111
110101101010111
010011010110111
010100011000100
110010100100100
001111000010100
101001111110100
100011001000010
000101110100010
111000010010010
011110101110010
100001010001101
000111101101101
111010001011101
011100110111101
010110000001011
110000111101011
001101011011011
101011100111011
101001111000010
001111000100010
110010100010010
010100011110010
011100110001011
111010001101011
000111101011011
100001010111011
011110101000100
111000010100100
000101110010100
100011001110100
101011100001101
001101011101101
110000111011101
010110000111101
010001001001110
110111110101110
001010010011110
101100101111110
100100000000111
000010111100111
111111011010111
011001100110111
100110011001000
000000100101000
111101000011000
011011111111000
010011010000001
110101101100001
001000001010001
101110110110001
010011100001000
110101011101000
001000111011000
101110000111000
100110101000001
000000010100001
111101110010001
011011001110001
100000111001110
000110000101110
111011100011110
011101011111110
010101110000111
110011001100111
001110101010111
101000010110111
110001000000100
010111111100100
101010011010100
001100100110100
000100001001101
100010110101101
011111010011101
111001101111101
111100001000010
011010110100010
100111010010010
000001101110010
001001000001011
101111111101011
010010011011011
110100100111011
101101010000100
001011101100100
110110001010100
010000110110100
011000011001101
111110100101101
000011000011101
100101111111101
110100010001110
010010101101110
101111001011110
001001110111110
000001011000111
100111100100111
011010000010111
111100111110111
010110111000010
110000000100010
001101100010010
101011011110010
100011110001011
000101001101011
111000101011011
011110010111011
101010110000000
001100001100000
110001101010000
010111010110000
011111111001001
111001000101001
000100100011001
100010011111001


Non ho ben capito come intendi procedere.
Comunque, se vuoi, queste 256 colonne per 15 bit sono
leggermente più rappresentative:
 Numero bit = 15
 Numero colonne = 256
 Vincita media = 12.890625
 Punti/Colonne
  15:    256
  14:    3840
  13:    20736
  12:    7936
Ciao, Nino
000000000000000
000000000011111
000000011100011
000000011111100
000001100100101
000001100111010
000001111000110
000001111011001
000000101001010
000000101010101
000000110101001
000000110110110
000001001101111
000001001110000
000001010001100
000001010010011
000110000100110
000110000111001
000110011000101
000110011011010
000111100000011
000111100011100
000111111100000
000111111111111
000110101101100
000110101110011
000110110001111
000110110010000
000111001001001
000111001010110
000111010101010
000111010110101
001010001001011
001010001010100
001010010101000
001010010110111
001011101101110
001011101110001
001011110001101
001011110010010
001010100000001
001010100011110
001010111100010
001010111111101
001011000100100
001011000111011
001011011000111
001011011011000
001100001101101
001100001110010
001100010001110
001100010010001
001101101001000
001101101010111
001101110101011
001101110110100
001100100100111
001100100111000
001100111000100
001100111011011
001101000000010
001101000011101
001101011100001
001101011111110
010010100101011
010010100110100
010010111001000
010010111010111
010011000001110
010011000010001
010011011101101
010011011110010
010010001100001
010010001111110
010010010000010
010010010011101
010011101000100
010011101011011
010011110100111
010011110111000
010100100001101
010100100010010
010100111101110
010100111110001
010101000101000
010101000110111
010101011001011
010101011010100
010100001000111
010100001011000
010100010100100
010100010111011
010101101100010
010101101111101
010101110000001
010101110011110
011000101100000
011000101111111
011000110000011
011000110011100
011001001000101
011001001011010
011001010100110
011001010111001
011000000101010
011000000110101
011000011001001
011000011010110
011001100001111
011001100010000
011001111101100
011001111110011
011110101000110
011110101011001
011110110100101
011110110111010
011111001100011
011111001111100
011111010000000
011111010011111
011110000001100
011110000010011
011110011101111
011110011110000
011111100101001
011111100110110
011111111001010
011111111010101
100010101001101
100010101010010
100010110101110
100010110110001
100011001101000
100011001110111
100011010001011
100011010010100
100010000000111
100010000011000
100010011100100
100010011111011
100011100100010
100011100111101
100011111000001
100011111011110
100100101101011
100100101110100
100100110001000
100100110010111
100101001001110
100101001010001
100101010101101
100101010110010
100100000100001
100100000111110
100100011000010
100100011011101
100101100000100
100101100011011
100101111100111
100101111111000
101000100000110
101000100011001
101000111100101
101000111111010
101001000100011
101001000111100
101001011000000
101001011011111
101000001001100
101000001010011
101000010101111
101000010110000
101001101101001
101001101110110
101001110001010
101001110010101
101110100100000
101110100111111
101110111000011
101110111011100
101111000000101
101111000011010
101111011100110
101111011111001
101110001101010
101110001110101
101110010001001
101110010010110
101111101001111
101111101010000
101111110101100
101111110110011
110000001100110
110000001111001
110000010000101
110000010011010
110001101000011
110001101011100
110001110100000
110001110111111
110000100101100
110000100110011
110000111001111
110000111010000
110001000001001
110001000010110
110001011101010
110001011110101
110110001000000
110110001011111
110110010100011
110110010111100
110111101100101
110111101111010
110111110000110
110111110011001
110110100001010
110110100010101
110110111101001
110110111110110
110111000101111
110111000110000
110111011001100
110111011010011
111010000101101
111010000110010
111010011001110
111010011010001
111011100001000
111011100010111
111011111101011
111011111110100
111010101100111
111010101111000
111010110000100
111010110011011
111011001000010
111011001011101
111011010100001
111011010111110
111100000001011
111100000010100
111100011101000
111100011110111
111101100101110
111101100110001
111101111001101
111101111010010
111100101000001
111100101011110
111100110100010
111100110111101
111101001100100
111101001111011
111101010000111
111101010011000


Bello, praticamente occorrerebbe un tri-ridotto di 15 dp in 256 colonne a
garanzia di due vincite n-3.
Oppure (più facile) un bi-ridotto di 9dp minimo 2 n-2 e un ridotto di 6 dp,
ecc...
Molto interessante....

 Non ho ben capito come intendi procedere.
Supponi di usare questo ridotto per i primi 15 bit e di
tirare ad indovinare il sedicesimo: la vincita media sara'
di 12.890625+0.5 = 13.39+
Possiamo aiutare in qualche modo statistico la scelta
dell'ultimo bit? Direi di si'.
In 14080 casi su 32768 la Gina, quando deve codificare
i primi 15 bit, si trova nell'imbarazzo della scelta tra due
colonne del ridotto ugualmente rappresentative. Allora
guarda il sedicesimo bit: se e' uno sceglie la colonna piu'
alta, se e' zero quella piu' bassa.
Secondo il testo originale del problema esposto da FraSisto,
il Gino vede i risultati parziali man mano che scommette,
quindi alla 15.a scommessa lui conosce come la Gina ha
fatto la codifica e, nel caso in cui la Gina ha fatto una scelta,
sa come l'ha fatta e quindi sa qual e' il sedicesimo bit.
Abbiamo detto in 14080 casi su 32768 pari a 42.96875%
che porta la vincita dell'ultimo bit a 0,71484375 che sommata
alla vincita del ridotto a 15 porta la vincita media a 13.605
S.E.&.O.
Ciao!!!  ((^__^))'
Livio

Ciao Francesco,
mi e' piaciuta moltissimo la tua idea di usare le tipologie
di terne come elemento che i Gini si devono comunicare!
Sono pero' d'accordo con Livio che imporre l'errore nella
quaterna sia eccessivamente penalizzante, e che si debba
cercare di evitarlo. Per ora non so come, ma ci pensero'
un po' su.  :-)
Ciao,
       Antonio     

l'informazione errata sul segno,
Questo modo di ottenere la garanzia del 13, grazie alla sua 
semplicita' e compattezza, mi sembra molto piu' elegante
dell'uso dei tririduttori. Ottima trovata, Nino!
L'idea che Gino e Gina dovessero per forza andare in giro con
uno sviluppo di 256 colonne in tasca mi aveva sempre un po'
infastidito...  ;-)
Saluti,
          iant

sedicesimo bit vale uno, e viceversa.
Mi sembra un'idea bellissima!!!
Come gia' suggerito da Francesco, il non plus ultra sarebbe
trovare sistemi ridotti con garanzia di due vincite di
categoria minima.
Prendendo quindi questo spunto sono andato a vedere sul sito
http://www.toto1x2.it
 che tiene traccia di tutti i ridotti
record e, se non ho mal interpretato le tabelle, dovrebbe
esistere un biridotto di 11 doppie a garanzia di 2 n-2,
formato da 64 colonne, che richiedera' quindi 6 bit.
Il record e' del 1981 ed e' stato attribuito a "Ciaburri V. & I.",
e spero che Nino possa riuscire a procurarcelo. (Altrimenti
cerchiamo di mettere sotto qualcuna delle nostre Darwin Machine ;-)
Con un tale sistema i casi sono due:
a) indovino 10 o 11 lanci
b) indovino 9 lanci *E* mi faccio uscire fuori un bit
   con il metodo di Livio.
Allora, a seconda dell'esito dei primi 11 lanci, i 5 lanci
rimanenti potranno essere affrontati in uno dei seguenti modi:
1. Con due bit nel caso in cui ho fatto 10/11 o 11/11
   e in questo caso uso 
p.es
. questo biridotto
   00111
   01000
   10100
   11011
   vincita minima 3   media 3.875
2. Con "due bit + uno" nel caso in cui ho fatto 9
 
   e in questo caso uso 
p.es
. questo ridotto per i primi 4 lanci
   0000
   0110
   1011
   1101
 
   vinc. min 3   media 3.25 
   e uso il "bit in piu'" per l'ultimo lancio, quindi in tutto:
 
   vincita minima 4   media 4.25 
Pertanto in ognuno dei due casi il 13/16 e' garantito.
Se e quando avremo il sistema biridotto di 11 doppie a garanzia di
due n-2, potremo anche calcolare la media precisa.
Saluti,
         iant

 cerchiamo di mettere sotto qualcuna delle nostre Darwin Machine ;-)
Nello stesso sito, nell'area download puoi scaricare gratuitamente un 
biridotto per 10 doppie 32 colonne,  con garanzia di 2 vincite e' 
codificato come 00100022 (Occorre pero' prima chiedere la password, che 
ti verra' inviata per e-mail)

 Con questo battiamo il record (13.601) di Giorgio Vecchi!!!!
Ho ampliato leggermente il programma di analisi ed ho trovato
una gradevole sorpresa:
**************************************
Numero bit = 15
Numero colonne = 256
Vincita media = 12.890625
Punti/Colonne
 15:    256
 14:    3840
 13:    20736
 12:    7936
 11:    0
Numero ridondanti = 14080
V(12) ridondanti = 7936
Vincita media su 16 bit = 13.60546875
**************************************
Poiche' *tutte* le colonne che realizzano 12 punti nel
ridotto da 15 coppie sono "ridondanti", allora la vincita
minima da 13 punti e' garantita!!!!!!
Il presente, quindi, batte tutti i record precedenti, almeno
fin che regge.  :o))))
Ciao!!!  ((^__^))'
Livio


Perņ, mi intrigava che si parlasse un po' di sistemistica
e riduzioni di doppie ;-))
Ciao, Nino


Ma un po' di merito lasciamolo a Giorgio ;-). Infatti, le 256
colonne che ti ho inviato sono semplicemente le sue (a cui ho
tolto il 6° bit)
Ciao, Nino


Uno non può nemmeno svegliarsi con calma e mettersi a leggere distrattamente
i vari messaggi che si sente chiamato in causa e per di più con nome e
cognome (a scanso di equivoci)! Mi hai costretto a rileggere con attenzione
tutto il thread e, per giunta, a capirne anche il contenuto! ;-)
Scherzi a parte, la tua idea è davvero molto bella! Col senno di poi (il
nostro; tu ce l'hai avuto prima! (il senno)) ci rendiamo tutti conto di
quanto sciocco fosse buttare alle ortiche tanta informazione!
E' pur vero che questa idea non è applicabile a quei giochi in cui la
"giocata" la fai prima e poi devi solo stare a vedere cosa "esce". In questo
caso penso che continui a valere il famoso limite teorico di 13.605+. Nel
tuo caso invece il limite si estende e chissà quanto è (scommetto però che
sia <= 16 !).
Secondo me la cosa non finisce qui. Le ridondanze possono essere doppie,
triple, quadruple eccetera. Si potrebbe sfruttare anche questa informazione.
Ho provato a vedere cosa succede se ci limitiamo a fornire 14 bit tentando
di desumere i rimanenti 2 in base ai vari tipi di ridondanze. Se la
ridondanza non c'è bisogna indovinarli tutti e due e quindi in media se ne
indovina 1. Se è doppia, bisogna indovinarne 1 (media 1.5). Se è tripla, si
dovrebbe arrivare a una media di 11/6. Se è quadrupla (o più) si indovinano
tutti e 2. Non ho dati buoni a disposizione ma confrontando due generazioni
simili da 15 e da 14 continua a essere molto superiore quella da 15.
Però prima di abbandonare l'idea si potrebbe fare un altro tentativo. Lo
butto lì, non ci ho ancora pensato e forse dico una stupidata. L'idea è di
trovare un sistema di comunicazione misto: predisporre la tabella delle 256
giocate con sequenze di bit che possono essere lunghe 16, 15, 14 ecc. in
base alle opportune ridondanze che vi possono essere. Boh, l'ho detta.
Adesso ci penso su.
Ciao e complimenti!
Giorgio


Abbiamo raggiunto il valore di vincita media del tririduttore
teorico perfetto di 16 doppie con 256 colonne, quindi con
questo meccanismo il record dovrebbe reggere per sempre...
Nino


Buon lavoro, Nino
0101010110
1010010110
0110100110
1001100110
0101011001
1010011001
0110101001
1001101001
0101101111
1010101111
1001011111
0110011111
0101100000
1010100000
1001010000
0110010000
0000001010
1111001010
0011111010
1100111010
0000000101
1111000101
0011110101
1100110101
0000110011
1111110011
0011000011
1100000011
0000111100
1111111100
0011001100
1100001100
----------
01010101100
01010110010
01101001100
01101010010
10011001100
10011010010
10100101100
10100110010
00000001010
00000010100
00111101010
00111110100
11001101010
11001110100
11110001010
11110010100
00001100110
00001111000
00110000110
00110011000
11000000110
11000011000
11111100110
11111111000
01011000000
01011011110
01100100000
01100111110
10010100000
10010111110
10101000000
10101011110
11010111101
11010100011
11101011101
11101000011
00011011101
00011000011
00100111101
00100100011
10000011011
10000000101
10111111011
10111100101
01001111011
01001100101
01110011011
01110000101
10001110111
10001101001
10110010111
10110001001
01000010111
01000001001
01111110111
01111101001
11011010001
11011001111
11100110001
11100101111
00010110001
00010101111
00101010001
00101001111

 Vmedia = 9,40625
Molto interessante!!!
Ci sono parecchie colonne che realizzano piu' di due vincite
a n-2, e che quindi possono essere usate per trasmettere una
informazione maggiore del bit!!! Il calcolo della media si
fa un po' piu' complicato, pero'.   :-)
Ancora grazie e a presto,
                           Antonio

 questo meccanismo il record dovrebbe reggere per sempre...
Gia'... ma il fatto che la vincita media sia *identica*, fino
all'ultimo decimale, al limite teorico calcolato da Giorgio
(senza il cognome, senno' si sente costretto a leggerci  :o))
per un sistema ridotto ideale "ad anello aperto", cioe' senza
i risultati parziali che sfruttiamo noi, mi lascia alquanto
perplesso... Che vuol dire?
Vuol forse dire che, contrariamente a quello che ci suggeriva
l'istinto, il vedere i risultati parziali non aggiunge nulla all'informazione
degli otto bit? Forse si'. Forse ci ha solo permesso di affinare
la risoluzione, di eliminare l'effetto di una discretizzazione dei
dati che non ci permetteva di raggiungere *esattamente* il limite.
Se e' cosi', allora si' che il "record reggera' per sempre" e  i
prossimi tentativi saranno solo ricerche di pietre filosofali e
moti perpetui.
Ai posteri...
Ciao!!!  ((^__^))'
Livio


Nonostante il gran bel risultato di Livio, io sono convinto che anche con
l'approccio ad errori si possa ottenere di più.
A ben pensarci Livio riesce a veicolare un'informazione aggiuntiva, sul 16
lancio, tramite *tre errori* nell'intero byte.
Francesco

minima da 13 punti e' garantita!!!!!!
Vuoi un'altra gradevole sorpresa?
Ho appena finito di scrivere il mio programma di analisi e
il dettaglio accorpato delle vincite del sistema triridotto
di Nino che stai usando e':
Tipo vincita  Colonne
 
       un 15  256    
       un 14  3840   
       un 13  14592  
      due 13  6144   
    sette 12  512    
      sei 12  2048   
   cinque 12  3328   
  quattro 12  1792   
      due 12  256    
Quindi si ha ridondanza 2 anche per molte vincite di 13 punti,
cosa che non avrei immaginato a priori, e poi una marea di
ridondanze multiple sui 12 punti, che sarebbero sfruttabili
ancora di piu' se non fosse che stiamo al penultimo lancio.
Secondo me si possono ampliare i risultati che hai immaginato
riducendo sistemi piu' piccoli e lasciandosi piu' lanci alla
fine per poter sfruttare le molteplicita' di colonne maggiori
di due. Con il tuo metodo colonne a molteplicita' 4 possono far
indovinare esattamente i due lanci successivi!
Che ne pensi?
Ciao,
       Antonio


Nino


Ho molti dubbi si possano realizzare vantaggi (perchè con sistemi
di meno bit si hanno, a parità di colonne, meno vincite multiple).
Ciao, Nino


Penso proprio che con il tuo metodo il limite teorico non si possa superare.
Infatti il Gino solo apparentemente crede di poter prendere autonomamente
decisioni sull'ultimo bit, ma in realtà così non è.
Provo a ricapitolare tutto il meccanismo: il Gino e la Gina stilano in
anticipo una tabella di 256 sequenze di 15 bit (non le chiamo più word
perché è un po' come chiamare "metro" un righello lungo 93.75 centimetri!).
Poi la Gina assiste ai 16 lanci e comunica al Gino, attraverso i suoi 8 bit
a disposizione, la colonna che il Gino deve giocare.
Il Gino la gioca, pedissequamente fino al 15 bit. Quindi sulla base di ciò
che è effettivamente uscito, decide quale sarà l'ultimo bit da giocare. Se
non ha informazioni di ridondanza, giocherà a caso, indovinando una volta su
due; se ha informazioni di ridondanza giocherà il bit che la Gina gli ha
segnalato di giocare. Nel caso in cui il Gino si trova a poter scegliere
l'ultimo bit, potrebbe tranquillamente giocare sempre 0, senza che questo
cambi la vincita media finale. Quindi in tutti i casi il gioco del Gino è
predeterminato e non aggiunge o non desume alcuna informazione in più di
quanto la Gina gli abbia trasmesso. In poche parole la Gina *sa* quale
sequenza il Gino giocherà.
Quindi, di fatto, il mettersi d'accordo sull'uso di quella tabella di 256
sequenze da 15 bit coincide con il far sì che il Gino giochi una ben precisa
sequenza di 16 bit tra 256 sequenze inizialmente predeterminate.
Allora, comunque la giriamo, la scelta che i due fanno è la migliore tra 256
possibili, quindi i calcoli fatti all'epoca e che stabilivano il limite
teorico dovrebbero valere ancora (con buona pace di Livio!).
Detto questo, credo che, se si vuole strappare un possibile miglioramento,
sempre rimanendo nell'ambito dei sistemi ridotti, si debba provare a
rimuovere il limite delle 256 sequenze. Butto lì un'idea: se potessimo
disporre di 512 sequenze, la vincita media arriverebbe a 14.140+ (se non ho
sbagliato i conti). Ora il problema è segnalare con 8 bit la sequenza
ottimale tra 512. E' chiaro che non si può. Però si potrebbe pensare di fare
così: si mettono in ordine le 512 sequenze in modo che, per ogni possibile
esito, vicino alla sequenza ottimale (che garantisce la media del 14.140) ci
sia sempre una sequenza che non scenda sotto 13.07031. In questo modo
indicando con gli 8 bit la coppia (e il Gino giocherà a caso una delle due),
si avrà la certezza che la media è almeno uguale a 13.065 (il limite fino ad
ora).
Non so se quello che ho appena detto sia realizzabile e sicuramente non mi
ci metto, però se qualcuno vuole prendere spunto dall'idea... Oppure a
smontarmela completamente dimostrando che è una gran sciocchezza...
Ciao e buona giornata :-)
Giorgio

 Che ne pensi?
Penso che l'*informazione* non si crei e non si distrugga, ma
si trasformi, al limite perdendone un po' per la strada, e che in
8 bit su 8 ci sia tanta informazione quanta in 13.60546875 bit su 16.
E che nessun salto mortale triplo carpiato possa estrarne di piu'.
Oppure che il fatto di estrarre quel numero con la precisione di
8 cifre decimali da due metodi cosi' diversi sia una di quelle
combinazioni che capitano una volta ogni trilione di post su IHE.  :o)
Ho ahime' paura di non avere (ancora) gli strumenti per capire
a fondo l'equazione:
Info(8, 8) = Info(13.60546875, 16)
ma il naso mi dice che siamo vicini ad una verita' matematica.
Purtroppo (per ora) e' soltanto un'opinione.
Ciao!!!  ((^__^))'
Livio

 Purtroppo (per ora) e' soltanto un'opinione.
Che cos'e' l'*informazione*?
Credo che il contenuto di informazione di un dato si possa
(ri)definire come l'inverso della probabilita' di indovinarlo
per caso.  (!)
Allora diremo che:
Info(8, 8) = 1/1/2^8 = 256
Info(13, 16) = 59.79+
Info(14, 16) = 963.76+
Info(13.60546875, 16) = ???
Vogliamo scommetere che vale 256?
Qualcuno sa fare il conto?
Ciao!!!  ((^__^))'
Livio

di meno bit si hanno, a parità di colonne, meno vincite multiple).
E' molto probabile che tu abbia ragione, pero' il tentativo
lo farei lo stesso. Hai per caso tra i tuoi sistemi un ridotto
a garanzia di 4 vincite di categoria minima?
Ciao,
       Antonio

Cosě utilizzi solo 7 bit totali.
Lo so che basta un bit per indovinarne 3 su 5, pero' poi con
il bit che ti avanza che ci fai?  :-)  Secondo me conviene usarli
tutti e due per tirare fuori la massima vincita possibile dai 5
lanci residui.
In effetti si potrebbe anche pensare ad una iterazione del metodo
di Livio, in cui uso un sistema di 4 colonne per ridurre i 4 lanci
successivi con garanzia di 2 modi di indovinare 3 lanci e il bit
che mi viene in piu' lo uso per indovinare l'ultimo lancio.
Pero' mentre scrivo mi viene il dubbio che questo sia del tutto
equivalente ad usare direttamente il riduttore a garanzia di 4
lanci su 5!  Mmmmm....
Saluti,
         Antonio

Info(8, 8) = Info(13.60546875, 16)
Bellissima sintesi della questione!!!
Io adoro le sintesi, perche' ripuliscono il campo dalle cose
ridondanti e fanno andare dritti al cuore delle questioni.
Direi che quell'equazione e' applicabile in modo del tutto
generale anche per altri valori. Quindi potremmo fare qualche
esperimento su equazioni a piu' bassa dimensionalita' per
abbassare i tempi di simulazione al computer.
Ho pensato di ripercorrere i passi che hanno portato al
calcolo dell'ormai famoso 13.60546875 teorico, per il problema
con un numero dimezzato di bit. Se non ho sbagliato i conti, il
risultato e':
Info(4, 4) = Info(6.625, 8)
Vedendo questo risultato si nota che se spezziamo in due il
problema dei Gini, tentando di indovinare separatamente
i primi 8 bit e gli ultimi 8 bit otteniamo un netto peggioramento
delle performance:  6.625 * 2 = 13.25  anziche'  13.60546875.
In pratica sembrerebbe che al crescere del numero di bit
si riesca a perdere percentualmente sempre meno informazione.
Digressione a parte, alla fine dei nostri salti mortali potremo
stilare l'interessantissima casistica generale
     Info(b, b) = Info(x, y)    [con y > b  e  x < y]
(che se la tua ipotesi e' giusta, potremo scrivere gia' da
subito, ma non si sa mai... ;-)
Al lavoro!
A presto,
           Antonio

Ho preparato un foglio di calcolo per determinare in modo
automatico alcuni valori dell'equazione di Livio, al fine
di valutare i limiti teorici dell'uso dei sistemi ridotti
sul "problema generalizzato dei Gini" :-)
Ho ottenuto i seguenti risulati:
Info(2, 2) = Info(3.25, 4)         [81.25% di info mantenuta] 
Info(4, 4) = Info(6.625, 8)        [82.8125%]
Info(8, 8) = Info(13.60546875, 16) [85.03418%]
Cioe' a parita' di rapporto tra dimensione della sequenza completa
e dimensione delle sequenza ridotta la percentuale x di informazione
mantenuta cresce al crescere della lunghezza della sequenza.
Invece:
Info(8, 8) = Info(8.5, 9)          [94.44444%]
Info(8, 8) = Info(9.25, 10)        [92.5%]
Info(8, 8) = Info(10.125, 11)      [92.04545%]
Info(8, 8) = Info(10.875, 12)      [90.625%]
Info(8, 8) = Info(11.46875, 13)    [88.22115%]  
Info(8, 8) = Info(12.25, 14)       [87.5%]  
Info(8, 8) = Info(13.078125, 15)   [87.1875%] 
Info(8, 8) = Info(13.60546875, 16) [85.03418%]
a parita' di lunghezza della sequenza ridotta mantengo
sempre meno informazione al crescere della sequenza completa.
Tornando al problema classico dei Gini, quest'ultimo risultato
ottenuto potrebbe suggerire che applicando il metodo di Livio su
una sequenza di lanci anche minore di 15 forse, dico *forse* ;-),
si potrebbe riuscire ad infilare un pelino di informazione in
piu'. Staremo a vedere.
Saluti,
         Antonio


Per quanto ne so, sistemi di questo tipo nella
sistemistica classica non vengono esplorati,
perchè non sono ritenuti di alcuna utilità,
nè teorica, nè pratica .
Infatti, la classificazione si ferma a 3(n-2)
per i biridotti e alla vincita singola per i
triridotti.
Però, esistono bellissime versioni a garanzia di
4 vincite con la riduzione n-1 (specialmente per
le triple). Tra le doppie, splendido è il
12 doppie: colonne 1024, ottenibile dalla molti-
plicazione e successiva somma dei 4 riduttori di
6 doppie a vincita doppia (ciascuno di 16 colonne).
A suo modo, questo è un riduttore perfetto, perchè
realizza le vincite secondo teoria, il 13 al 25%
oppure quattro 12 nel restante 75% dei casi.
Un semplicissimo riduttore a garanzia quadrupla è
anche il semi-integrale di 4 doppie di 8 colonne
(estraendo ad es. quelle con i segni pari).
Ciao, Nino

Io ho provato a ridurre sistemini di 2, 3 e 4 doppie a uno.
Mi sembra di poter scrivere:
Info(1, 1) = Info(1.5, 2) = Info(2.25, 3) = Info(2.75, 4)
Se e' vero che la quantita' di informazione di un dato e' l'inverso
della probabilita' di ricavare quel dato per caso, allora:
Info(1, 1) = 2
Vediamo gli altri:
Info(1.5, 2) = SQR(Info(3, 4)) = SQR(2^4/(4!/3!)) = 2   (eppero'!)
Info(2.25, 3) = (Info(9, 12))^(1/4) = (2^12/(12!/9!/3!))^(1/4) = 2.077
Info(2.75, 4) = (Info(11, 16))^(1/4) = (2^16/(16!/11!/5!)^(1/4) = 1.968
Info(8, 8) = 256
Info(13, 16) = 2^16/16!*13!*3! =~ 117
Info(14, 16) = 2^16/16!*14!*2! =~ 546
Info(13.60546875, 16) = ?  (117 < x < 546)
(secondo me = 256, ma non riesco a fare il calcolo)
Bah, sbaglio da qualche parte?
Buona notte!!!  ((^__^))'
Livio

 [...]
Concordo esattamente. Il metodo non *aggiunge* alcuna informazione
che la Gina non abbia gia' trasmesso. E' soltanto un algoritmo che
permette di sfruttarla tutta, e' un razzo a due stadi dove l'ultimo stadio
riesce a bruciare tutto il propellente residuo.
Ciao!!!  ((^__^))'
Livio

Ciao Livio.
Calcolando ridotti qua e la' ho trovato un riduttore di 6
doppie da 8 colonne a media 5, che coincide con la media
del riduttore ideale di 6 doppie a 8 colonne:
000001
001111
010110
011000
100100
101010
110011
111101
Punti Colonne
    6   8
    5  48
    4   8
L'equazione generata e' tutta a termini interi:
Info(3, 3) = Info(5, 6)
penso che possa tornare utile per poter verificare altre
ipotesi di formule che legano informazione e vincita media.
Ciao,
       Antonio

 sa come l'ha fatta e quindi sa qual e' il sedicesimo bit.
Scusa, ci torno dopo tanto perché anch'io in macchina spesso penso ai Gini.
Non ho capito come procedere.
Supponiamo che una sequenza di 15 bit sia egualmente rappresentata (13 punti
su 15) dalle colonne 78 e 85.
Un'altra realizza 13 sulle colonne 85 e 110.
Ora, quando Gina scrive 85 a Gino vuol dire a Gino che l'ultimo bit è 0
opure 1?
-- 
Ciao, Silv:o)
...che vi segue, ah se vi segue. avevo anche qualcosetta sui gini, ma sono
sempre stato anticipato

 č 0 opure 1?
Quando il Gino vede il 15.o bit sa che la Gina ha dovuto scegliere,
nel primo caso che tu citi: tra 78 e 85, nel secondo: tra 85 e 110.
Quindi possono aver convenuto che, ogni volta che la Gina puo'
fare la scelta, scelga il minore per dire 0 e il maggiore per dire 1.
Cioe':
1.o caso 78=0, 85=1
2.o caso 85=0, 110=1
Ciao, ci manchi soprattutto in questi conti!!!  ((^__^))'
Livio

 nel primo caso che tu citi: tra 78 e 85, nel secondo: tra 85 e 110.
ecco perché quando lessi il tuo messaggio non trovai nulla da obiettare!
forse all'epoca ancora ricordavo che gino scommeteva lancio per lancio ;)
Ieri sera ho dato una gugolata, sicuro di trovare moltissima letteratura
sull'argomento.
Stiamo parlando di compressione dati con perdita di informazione (lossy).
La mole delle cose presenti in rete è sterminata, ovviamente.
Mi pare di aver capito che in scienza dell'informazione si chiami
distorsione il complementare della vincita media che abbiamo considerato
noi. per esempio, la distorsione del codice ottimale per il problema dei
gini dovrebbe valere 2.394+
La distorsione misura la distanza (nel nostro caso la differenza di bit)
media tra il segnale originale e quello ricostruito. In pratica ogni stringa
di n bit ha una codifica compressa di m bit. La funzione di codifica non è
invertibile, altrimenti la codifica sarebbe lossless, ed in generale la
funzione di decodifica non sempre restituisce la giusta origine. Bene, se si
fa la media delle distanze si ottiene relativa al codice usato (ed al
bitrate ovviamente).
Keywords per ricerche:
lossy source compression, binary iid source (è il nostro esperimento:
sorgente di dati binari indipendenti ed identicamente distribuiti),
rate-distorction function
come al solito i giapponesi sono i più forti di tutti
-- 
Ciao, Silv:o)