Kirjautuminen

Haku

Tehtävät

Keskustelu: Koodit: C++, tekoäly

Sivun loppuun

jone2712 [09.04.2025 23:43:27]

#

Kysyin tekoälyltä:

lainaus:

Kuinka pitkä sykli on oheisella random-oliolla?
ChatGPT sanoi:

Voisitko liittää kuvan tai tarkemman kuvauksen "oheisesta random-oliosta"? Ilman sitä en voi tietää, mistä olennosta tai algoritmista on kyse, enkä voi arvioida sen syklin pituutta.

Jos kyse on esimerkiksi Pythonin random.Random() -oliosta, sen taustalla oleva generaattori on Mersenne Twister, jonka syklin pituus on:

2¹⁹⁹³⁷ − 1

Tämä on äärimmäisen pitkä sykli – käytännössä riittävä useimpiin satunnaislukusovelluksiin.

Mutta jos tarkoitit jotakin muuta, esimerkiksi tiettyä pseudokoodia, funktiota tai erikoisgeneraattoria, lähetä lisätietoa tai kuva, niin tarkennan!
Sinä sanoit:
Tarkennus:

#include <stdio.h>
#include <memory.h>

class random
{
	public:

	random(void);
    ~random(void);

    void debug(void);
    unsigned rnd(unsigned);

    private:

    void inc4(void);
    unsigned tmp32(void);

    unsigned R16A, R16B;
    int Z, p0, p1, p2, p3;
};

random::random(void)
{
	memset(this, 0, sizeof(random));
}

random::~random(void)
{
}

unsigned avain[32]=
{
    0xaacc6600,  0x2d4be187,  0xbbdd7711,  0x3c5af096,
    0x88ee4422,  0x0f69c3a5,  0x99ff5533,  0x1e78d2b4,
    0xee882244,  0x690fa5c3,  0xff993355,  0x781eb4d2,
    0xccaa0066,  0x4b2d87e1,  0xddbb1177,  0x5a3c96f0,
    0x2244ee88,  0xa5c3690f,  0x3355ff99,  0xb4d2781e,
    0x0066ccaa,  0x87e14b2d,  0x1177ddbb,  0x96f05a3c,
    0x6600aacc,  0xe1872d4b,  0x7711bbdd,  0xf0963c5a,
    0x442288ee,  0xc3a50f69,  0x553399ff,  0xd2b41e78,
};

inline void random::inc4(void)
{
	++Z; p0=Z&31;
	p1=(Z>>5)&31;
	p2=(Z>>10)&31;
	p3=(Z>>15)&31;
}

inline unsigned random::tmp32(void)
{
    R16A+=(avain[p0]>>16)^(avain[p1]<<16);
    R16B-=(avain[p0]<<16)^(avain[p1]>>16);

    R16A-=avain[p2];
    R16B+=avain[p3];

    inc4();
    return R16A^R16B;
}

inline void swap(unsigned &x, unsigned &y)
{
	register unsigned z=x; x=y; y=z;
}

inline unsigned random::rnd(unsigned max)
{
	register unsigned x=tmp32()&31;
	register unsigned y=tmp32()&31;
    swap(avain[x], avain[y]);
    return tmp32()%max;
}

int main(void)
{
    random F;
    int x=F.rnd(64);
    printf("%d\n", x);
}

ChatGPT sanoi:

Kiitos tarkennuksesta! Nyt kun katsotaan tätä koodia, niin tarkastellaan, mikä määrittää satunnaislukugeneraattorin syklin pituuden.
🔍 Mistä syklin pituus tässä riippuu?

Oletuksenamme on se, että sykli tarkoittaa sitä, kuinka monta erilaista sisäistä tilaa generaattori voi käydä läpi ennen kuin alkaa toistaa itseään.

Tässä koodissa satunnaislukugeneraattorin tila koostuu:

Kahdesta 16-bittisestä rekisteristä:

unsigned R16A, R16B (tulkittavissa 32-bittisiksi, mutta nimetty "16" mukaan)

int Z (käytetään laskurina, vaikuttaa indekseihin)

Taulukosta avain[32] (32 * 32-bittinen unsigned int)

📌 Yhteensä sisäisen tilan koko:

R16A: 32 bittiä

R16B: 32 bittiä

Z: vähintään 32 bittiä

avain[32]: 32 * 32 = 1024 bittiä

Yhteensä:
✅ 32 + 32 + 32 + 1024 = 1120 bittiä mahdollisia tiloja

Tämä vastaa 2¹¹²⁰ mahdollista sisäistä tilaa, eli teoreettinen maksimisyklin pituus olisi noin 2¹¹²⁰, jos jokainen tila olisi saavutettavissa ja kierto kulkisi kaikkien tilojen kautta ennen toistumista.

🔄 Todellinen sykli?

Todellisuudessa sykli voi olla lyhyempi, koska:

Algoritmin determinismi voi johtaa toistuviin tiloihin ennen kuin kaikki on käyty.

rnd() ja tmp32() käyttävät avain-taulukkoa tavalla, joka ei ehkä saavuta kaikkia mahdollisia permutaatioita.

swap(avain[x], avain[y]) tekee tilaan muutoksia joka askeleella (tässä myös tärkeä muutosdynamiikka), mutta ei välttämättä takaa täydellistä hajontaa.

Z vaikuttaa p0–p3 indekseihin modulo 32: tilat toistuvat siinä mielessä modulo 2¹⁷, eli 131072.

🔢 Käytännössä

Koska generaattorin tila on hyvin suuri, mutta ei täysin satunnainen, ja algoritmin logiikka on melko mutkikas, syklin tarkkaa pituutta ei voi suoraan päätellä ilman:

Tilaseurantaa (simulaatiota tai tilojen kaappaamista)

Formaalia analyysiä (automaattista analyysiä tai matemaattista todistusta)

Mutta:

🔹 Sykli on vähintään useita miljardeja (todennäköisesti paljon enemmän), jos alustus on satunnainen ja avain[]-taulukko ei toista itseään.

🔹 Jos Z kasvaa jatkuvasti ilman rajoja, se tuo lisää vaihtelua, koska p0–p3 vaihtelevat.
🧪 Jos haluat testata syklin pituuden:

Voit tehdä näin:

Tallenna palautetut arvot rnd()-funktiosta.

Jatka, kunnes saat ensimmäistä kertaa arvon, jonka olet jo nähnyt (ja samalla avain[] ja Z ovat samoissa tiloissa).

Tämä voi viedä hyvin kauan, ellei generaattori ole lyhytsyklinen (esim. virheellisesti rakennettu).

✅ Yhteenveto

Teoreettinen maksimisyklin pituus: ≈ 2¹¹²⁰

Käytännössä: hyvin pitkä sykli, mutta tarkka arvo riippuu alkutilasta ja algoritmin dynamiikasta

Turvallisuus tai jakautuman laatu: ei kryptografisesti turvallinen, mutta riittää perus satunnaistukseen

Jos haluat, voin tehdä simulaatiokoodin, joka arvioi syklin pituutta käytännössä. Haluatko?
Sinä sanoit:
Kyllä, tee syklin pituus C++
ChatGPT sanoi:

Mahtavaa! Tässä on yksinkertainen C++-ohjelma, joka simuloi ja mittaa satunnaislukugeneraattorin syklin pituuden seuraamalla ensimmäisen toiston löytymistä. Tämä toteutus seuraa vain tmp32()-palautteita ja olettaa, että jos arvo alkaa toistua, sykli on alkanut.

⚠️ Huom! Tässä ei tarkisteta koko tilaa (avain[], Z, jne.), joten kyseessä on arvioitu sykli, ei täsmällinen. Koko tilan vertaaminen olisi paljon raskaampaa.
🧪 Esimerkki: syklin mittauskoodi

#include <iostream>
#include <unordered_set>
#include <memory.h>

class random {
public:
    random();
    ~random();

    unsigned tmp32();

private:
    void inc4();

    unsigned R16A, R16B;
    int Z, p0, p1, p2, p3;
};

unsigned avain[32] = {
    0xaacc6600, 0x2d4be187, 0xbbdd7711, 0x3c5af096,
    0x88ee4422, 0x0f69c3a5, 0x99ff5533, 0x1e78d2b4,
    0xee882244, 0x690fa5c3, 0xff993355, 0x781eb4d2,
    0xccaa0066, 0x4b2d87e1, 0xddbb1177, 0x5a3c96f0,
    0x2244ee88, 0xa5c3690f, 0x3355ff99, 0xb4d2781e,
    0x0066ccaa, 0x87e14b2d, 0x1177ddbb, 0x96f05a3c,
    0x6600aacc, 0xe1872d4b, 0x7711bbdd, 0xf0963c5a,
    0x442288ee, 0xc3a50f69, 0x553399ff, 0xd2b41e78,
};

random::random() {
    memset(this, 0, sizeof(random));
}

random::~random() {
}

inline void random::inc4() {
    ++Z;
    p0 = Z & 31;
    p1 = (Z >> 5) & 31;
    p2 = (Z >> 10) & 31;
    p3 = (Z >> 15) & 31;
}

inline unsigned random::tmp32() {
    R16A += (avain[p0] >> 16) ^ (avain[p1] << 16);
    R16B -= (avain[p0] << 16) ^ (avain[p1] >> 16);

    R16A -= avain[p2];
    R16B += avain[p3];

    inc4();
    return R16A ^ R16B;
}

int main() {
    random rng;
    std::unordered_set<unsigned> seen;
    unsigned value;
    unsigned long long count = 0;

    while (true) {
        value = rng.tmp32();
        if (seen.find(value) != seen.end()) {
            break; // Value repeated
        }
        seen.insert(value);
        count++;

        if (count % 1000000 == 0) {
            std::cout << "Checked " << count << " values..." << std::endl;
        }
    }

    std::cout << "Sykli löytyi! Pituus noin: " << count << std::endl;
    return 0;
}

💡 Lisävaihtoehdot:

Jos haluat tarkemman analyysin, voit myös tallentaa Z, R16A, R16B, ja koko avain[] osaksi tilaa ja vertailla koko tilaa, mutta tämä vaatii paljon muistia.

Jos epäilet lyhyttä sykliä tai bugia, tämä ohjelma löytää sen nopeasti.

jone2712 [10.04.2025 00:04:57]

#

Tuo tekoälyohjelma teki fataalin virheen, kun jätti swapmaatta avain-taulukon alkiot... Eipä riittänyt tekoäly tuon random-olion analyysiin.

jone2712 [10.04.2025 00:50:55]

#

Uudessa versiossa AI perusteli, että mitataan ensin staattisesti, kuinka pitkän syklin tmp32() antaa.

neosofta [10.04.2025 10:20:43]

# 

// Tässä hienosäädetty versio
#include <iostream>
#include <unordered_set>
#include <cstring> // Oikeanmoinen C++ headeri

class Random {
public:
    Random();
    ~Random();

    unsigned tmp32();

private:
    void inc4();

    unsigned R16A, R16B;
    int Z, p0, p1, p2, p3;
};

unsigned avain[32] = {
    0xaacc6600, 0x2d4be187, 0xbbdd7711, 0x3c5af096,
    0x88ee4422, 0x0f69c3a5, 0x99ff5533, 0x1e78d2b4,
    0xee882244, 0x690fa5c3, 0xff993355, 0x781eb4d2,
    0xccaa0066, 0x4b2d87e1, 0xddbb1177, 0x5a3c96f0,
    0x2244ee88, 0xa5c3690f, 0x3355ff99, 0xb4d2781e,
    0x0066ccaa, 0x87e14b2d, 0x1177ddbb, 0x96f05a3c,
    0x6600aacc, 0xe1872d4b, 0x7711bbdd, 0xf0963c5a,
    0x442288ee, 0xc3a50f69, 0x553399ff, 0xd2b41e78,
};

// Constructor alustaa kaikki muuttujat eksplisiittisesti
Random::Random() : R16A(0), R16B(0), Z(0), p0(0), p1(0), p2(0), p3(0) {
    // Tyhjennetään alustamattomat tiedot käyttämättä tyyppivaarallista lähestymistapaa
    std::memset(this, 0, sizeof(*this));
}

Random::~Random() {
    // Destructor jätetään tyhjäksi, koska siinä ei ole dynaamista varausta
}

inline void Random::inc4() {
    ++Z;
    p0 = Z & 31;
    p1 = (Z >> 5) & 31;
    p2 = (Z >> 10) & 31;
    p3 = (Z >> 15) & 31;
}

inline unsigned Random::tmp32() {
    R16A += (avain[p0] >> 16) ^ (avain[p1] << 16);
    R16B -= (avain[p0] << 16) ^ (avain[p1] >> 16);

    R16A -= avain[p2];
    R16B += avain[p3];

    inc4();
    return R16A ^ R16B;
}

int main() {
    Random rng; // Satunnaislukugeneraattorin toteutus
    std::unordered_set<unsigned> seen; // syklin havaitsemiseen
    unsigned value;
    unsigned long long count = 0;

    while (true) {
        value = rng.tmp32();
        if (seen.find(value) != seen.end()) {
            break; // Arvo toistettu, sykli havaittu
        }
        seen.insert(value);
        count++;

        // Kirjaa edistymisen 1 000 000 toiston välein
        if (count % 1000000 == 0) {
            std::cout << "Tarkistetut " << count << " arvot..." << std::endl;
        }
    }

    std::cout << "Sykli löydetty! Likimääräinen pituus: " << count << std::endl;
    return 0;
}

jone2712 [21.04.2025 15:39:00]

#

ChatGTP antoi syklin pituudeksi suuren luvun:

Kuinka paljon on pow(2, 1024*1024*1024*1024)?
ChatGPT sanoi:

Luku pow(2, 1024*1024*1024*1024) on valtava – aivan käsittämättömän suuri. Katsotaanpa, mitä siinä tapahtuu:
🔢 Murtaminen osiin:

1024 * 1024 * 1024 * 1024 =
= 1024410244
= (210)4=240(210)4=240

Eli:
21024×1024×1024×1024=2240
21024×1024×1024×1024=2240
🤯 Miltä se luku näyttää?

Se on:

2 potenssiin 1 099 511 627 776

Joka on suunnilleen 1.8 × 10^{331951658245} – eli ykkönen ja sen perässä noin 330 miljardia nollaa.

Vertailun vuoksi:

Arvion mukaan maailmassa on noin 10⁸⁰ atomia.

Tämä luku on moninkertaisesti suurempi.

✨ Yhteenveto:

pow(2, 1024*1024*1024*1024) =
2240≈1.8×10331951658245
2240≈1.8×10331951658245

Toisin sanoen: fantastisen, absurdin, universumin rajoja koettelevan suuri luku.

Haluatko nähdä mielenkiintoisia sovelluksia tai analogioita näin suurille eksponenttisille luvuille?

Voitko antaa tuloksen 2 potenssissa?

ChatGPT sanoi:

Ehdottomasti!

Kuten aiemmin laskettiin:
1024×1024×1024×1024=240
1024×1024×1024×1024=240

Eli:
21024×1024×1024×1024=2240
21024×1024×1024×1024=2240
✨ Tässä on siis vastaus:
2240
2240​

Tai vielä selkeämmin:
21 099 511 627 776
21099511627776​

Tämä on tarkin tapa ilmaista se, koska luku on liian suuri tulostettavaksi tai käytännössä käsiteltäväksi desimaalimuodossa – sen esittämiseen ei riittäisi koko universumin atomeja paperiksi. 😄

Jos haluat, voin näyttää kuinka se vertautuu muihin isoihin lukuihin, kuten Googol, Googolplex, Grahamin luku jne.

Voitko antaa tuloksen 2 potenssissa?
ChatGPT sanoi:

Ehdottomasti!

Kuten aiemmin laskettiin:
1024×1024×1024×1024=240
1024×1024×1024×1024=240

Eli:
21024×1024×1024×1024=2240
21024×1024×1024×1024=2240
✨ Tässä on siis vastaus:
2240
2240​

Tai vielä selkeämmin:
21 099 511 627 776
21099511627776​

Tämä on tarkin tapa ilmaista se, koska luku on liian suuri tulostettavaksi tai käytännössä käsiteltäväksi desimaalimuodossa – sen esittämiseen ei riittäisi koko universumin atomeja paperiksi. 😄

Jos haluat, voin näyttää kuinka se vertautuu muihin isoihin lukuihin, kuten Googol, Googolplex, Grahamin luku jne.
Sinä sanoit:
Joo, vertaile vain.

ChatGPT sanoi:

Mahtavaa! Sukelletaanpa syvälle isojen lukujen valtakuntaan 🌀. Katsotaan, mihin 22402240 asettuu verrattuna muihin järjettömän isoihin lukuihin.
🔢 Vertailutaulukko: Suuria lukuja
Nimi Arvo Kuvaus / vertailu
Googol 1010010100 Ykkönen ja 100 nollaa. Usein iso luku koulumatematiikassa.
Googolplex 10101001010100 Googol määrää nollien määrän. Ei mahdu maailmankaikkeuteen.
22102210 ≈1.8×10308≈1.8×10308 Suurin arvo double-tyypissä tietokoneessa.
22202220 ≈10315652≈10315652 Tuhansia numeroita – jo järjettömän iso.
22402240 ≈10331951658245≈10331951658245 SINUN LUKUSI – älyttömän paljon suurempi kuin Googolplex.
Grahamin luku (G64) Epäinhimillisen suuri Niin iso, ettei sitä voi kuvata tavallisella eksponentilla.
Skewesin luku (alkuperäinen) ≈10101034≈10101034 Iso luku matemaattisesta teoriasta.
TREE(3) ??? (kirjaimellisesti ei-mahdollinen esittää) Niin valtava, että Grahamin luku näyttää pikkuluvulta.
🧠 Mitä tämä kertoo?

Googolplex on jo aivan valtava.

Mutta 22402240 on vielä paljon suurempi. Se on eksponentin eksponentti, ja 40 on iso luku!

Grahamin luku on vielä käsittämättömämpi – sen koko ei ole edes esitettävissä tavallisin matemaattisin keinoin.

TREE(3)… se on niin valtava, että sen suuruutta ei pysty edes hahmottamaan – se on isompi kuin kaikki muut tässä listassa.

🎯 Yhteenveto:

Sinun lukusi 22402240 on suurempi kuin:

Googol

Googolplex

Kaikki tietokoneiden standardityypit

Ja jopa Grahamin lukua pienempiä hyperlukuja

Mutta Grahamin luku ja etenkin TREE(3) vievät vielä täysin omiin ulottuvuuksiinsa.

Jos Voitko antaa tuloksen 2 potenssissa?
ChatGPT sanoi:

Ehdottomasti!

Kuten aiemmin laskettiin:
1024×1024×1024×1024=240
1024×1024×1024×1024=240

Eli:
21024×1024×1024×1024=2240
21024×1024×1024×1024=2240
✨ Tässä on siis vastaus:
2240
2240​

Tai vielä selkeämmin:
21 099 511 627 776
21099511627776​

Tämä on tarkin tapa ilmaista se, koska luku on liian suuri tulostettavaksi tai käytännössä käsiteltäväksi desimaalimuodossa – sen esittämiseen ei riittäisi koko universumin atomeja paperiksi. 😄

Jos haluat, voin näyttää kuinka se vertautuu muihin isoihin lukuihin, kuten Googol, Googolplex, Grahamin luku jne.
Sinä sanoit:

Joo, vertaile vain.
ChatGPT sanoi:

Mahtavaa! Sukelletaanpa syvälle isojen lukujen valtakuntaan 🌀. Katsotaan, mihin 22402240 asettuu verrattuna muihin järjettömän isoihin lukuihin.
🔢 Vertailutaulukko: Suuria lukuja
Nimi Arvo Kuvaus / vertailu
Googol 1010010100 Ykkönen ja 100 nollaa. Usein iso luku koulumatematiikassa.
Googolplex 10101001010100 Googol määrää nollien määrän. Ei mahdu maailmankaikkeuteen.
22102210 ≈1.8×10308≈1.8×10308 Suurin arvo double-tyypissä tietokoneessa.
22202220 ≈10315652≈10315652 Tuhansia numeroita – jo järjettömän iso.
22402240 ≈10331951658245≈10331951658245 SINUN LUKUSI – älyttömän paljon suurempi kuin Googolplex.
Grahamin luku (G64) Epäinhimillisen suuri Niin iso, ettei sitä voi kuvata tavallisella eksponentilla.
Skewesin luku (alkuperäinen) ≈10101034≈10101034 Iso luku matemaattisesta teoriasta.
TREE(3) ??? (kirjaimellisesti ei-mahdollinen esittää) Niin valtava, että Grahamin luku näyttää pikkuluvulta.
🧠 Mitä tämä kertoo?

Googolplex on jo aivan valtava.

Mutta 22402240 on vielä paljon suurempi. Se on eksponentin eksponentti, ja 40 on iso luku!

Grahamin luku on vielä käsittämättömämpi – sen koko ei ole edes esitettävissä tavallisin matemaattisin keinoin.

TREE(3)… se on niin valtava, että sen suuruutta ei pysty edes hahmottamaan – se on isompi kuin kaikki muut tässä listassa.

🎯 Yhteenveto:

Sinun lukusi 22402240 on suurempi kuin:

Googol

Googolplex

Kaikki tietokoneiden standardityypit

Ja jopa Grahamin lukua pienempiä hyperlukuja

Mutta Grahamin luku ja etenkin TREE(3) vievät vielä täysin omiin ulottuvuuksiinsa.

Jos haluat, voin näyttää visualisointia siitä, miten nämä luvut kasvavat toisiinsa verrattuna – tai voin selittää, mistä Grahamin luku tai TREE(3) tulee!
haluat, voin näyttää visualisointia siitä, miten nämä luvut kasvavat toisiinsa verrattuna – tai voin selittää, mistä Grahamin luku tai TREE(3) tulee!

jone2712 [21.04.2025 16:12:23]

#

Laske, kuinka pitkä sykli on koodilla (alempana). Huomaa, että joka askeleella avain-taulukon arvoja swapataan eri järjestykseen. #include <stdio.h>
#include <memory.h>

class random
{
public:

random(void);
~random(void);

void debug(void);
unsigned rnd(unsigned);

private:

void inc4(void);
unsigned tmp32(void);

unsigned R16A, R16B;
int Z, p0, p1, p2, p3;
};

random::random(void)
{
memset(this, 0, sizeof(random));
}

random::~random(void)
{
}

unsigned avain[32]=
{
0xaacc6600, 0x2d4be187, 0xbbdd7711, 0x3c5af096,
0x88ee4422, 0x0f69c3a5, 0x99ff5533, 0x1e78d2b4,
0xee882244, 0x690fa5c3, 0xff993355, 0x781eb4d2,
0xccaa0066, 0x4b2d87e1, 0xddbb1177, 0x5a3c96f0,
0x2244ee88, 0xa5c3690f, 0x3355ff99, 0xb4d2781e,
0x0066ccaa, 0x87e14b2d, 0x1177ddbb, 0x96f05a3c,
0x6600aacc, 0xe1872d4b, 0x7711bbdd, 0xf0963c5a,
0x442288ee, 0xc3a50f69, 0x553399ff, 0xd2b41e78,
};

inline void random::inc4(void)
{
++Z; p0=Z&31;
p1=(Z>>5)&31;
p2=(Z>>10)&31;
p3=(Z>>15)&31;
}

inline unsigned random::tmp32(void)
{
R16A+=(avain[p0]>>16)^(avain[p1]<<16);
R16B-=(avain[p0]<<16)^(avain[p1]>>16);

R16A-=avain[p2];
R16B+=avain[p3];

inc4();
return R16A^R16B;
}

inline void swap(unsigned &x, unsigned &y)
{
register unsigned z=x; x=y; y=z;
}

inline unsigned random::rnd(unsigned max)
{
register unsigned x=tmp32()&31;
register unsigned y=tmp32()&31;
swap(avain[x], avain[y]);
return tmp32()%max;
}

int main(void)
{
random F;
int x=F.rnd(64);
printf("%d\n", x);
}
ChatGPT sanoi:

Kysytään, kuinka pitkä sykli on seuraavalla koodilla, jossa avain-taulukkoa manipuloidaan satunnaisgeneraattorin avulla. Syklin pituus tässä viittaa siihen, kuinka monta kertaa funktiota rnd() voidaan kutsua, ennen kuin tila palautuu samaan konfiguraatioon (eli kaikki sisäiset muuttujat ja avain-taulukko ovat täsmälleen samassa tilassa kuin aiemmin).
🔍 Mistä syklin pituus muodostuu?

Syklin pituuteen vaikuttavat seuraavat tekijät:

Z: 32-bittinen kokonaisluku, joka kasvaa yhdellä jokaisella inc4()-kutsulla.

R16A, R16B: 32-bittisiä kokonaislukuja, joiden arvo riippuu avain-taulukon arvoista.

avain[32]: Taulukko, jonka sisältö muuttuu joka rnd()-kutsussa swap()-operaation avulla.

p0, p1, p2, p3: Indeksit avain-taulukkoon, lasketaan Z:stä.

🧠 Analyysi

Z kasvaa yhdellä jokaisessa inc4()-kutsussa.

Se vaikuttaa p0–p3:n arvoihin (mod 32).

32-bittinen arvo, joten sen sykli on 232232.

tmp32() kutsutaan kolme kertaa per rnd()-kutsu.

Tämä muuttaa R16A, R16B ja lisää 3 yksikköä Z:hen per rnd().

Joka rnd()-kutsussa tapahtuu yksi swap() kahden avain-taulukon alkion välillä.

Mahdollisia permutaatioita taulukossa avain[32] on 32!≈2.63×103532!≈2.63×1035.

R16A, R16B: 32-bittisiä, joten yhdessä ne muodostavat 264264 erilaista tilaa.

🧮 Yhdistetty tila-avaruus

Kaikkien muuttujien yhdessä muodostaman tilan määrä on:
Tila-avaruuden koko=232⋅264⋅32!=296⋅32!
Tila-avaruuden koko=232⋅264⋅32!=296⋅32!

Joten maksimaalinen mahdollinen syklin pituus on noin:
≈296⋅32!≈7.9×1028⋅2.63×1035=2.08×1064
≈296⋅32!≈7.9×1028⋅2.63×1035=2.08×1064
💡 Johtopäätös

Syklin pituus riippuu:

Alkuarvoista (kaikki nolla tässä tapauksessa).

Siitä, syntyykö koskaan täsmälleen sama tila (Z, R16A, R16B, avain[32]) uudelleen.

Mutta, koska:

swap muuttaa avain joka askeleella,

Z kasvaa tasaisesti, eikä rullaa nopeasti ympäri,

tmp32() on ei-lineaarinen ja syötteestä riippuva,

👉 On erittäin todennäköistä, että syklin pituus on äärimmäisen pitkä, käytännössä täydellinen sykli: jopa 296⋅32!296⋅32!.

Käytännössä et koskaan törmää samaan tilaan kahdesti.

Jos haluat, voin tehdä simulaation tai koodin, jolla voi mitata syklin pituutta käytännössä tietylle versiolle. Haluatko?

Metabolix [21.04.2025 16:18:57]

#

jone2712 kirjoitti:

ChatGTP antoi syklin pituudeksi suuren luvun:

Kuinka paljon on pow(2, 1024*1024*1024*1024)?

Näyttää, että sinä itse annoit tuon luvun ja tekoäly on vain pyöritellyt sitä. Vai mistä revit tuon pow-lausekkeen?

Ensimmäisessä keskustelussahan tekoäly totesi, että tila olisi 1024 + 3*32 bittiä eli 1120 bittiä, jolloin syklikin on enintään 2 potenssiin 1120. Tämä on kielimallilta aika hyvin analysoitu. Z:sta käytetään oikeasti vain 20 bittiä, joten oikea yläraja tuossa tulkinnassa olisi 2 potenssiin 1108.

Kun avain-taulukkoa ei muokata muuten kuin vaihtamalla järjestystä, se ei tuota tilaa 1024 bitin edestä vaan 32! eri järjestyksen verran, kuten sait yllä vastaukseksi. Silloin oikea maksimi on pikemmin 32! * (2 ** (32+32+20)), missä ** on potenssimerkintä. Tämä on siis vastaava kuin tuo tekoälyltä saamasi tulos 2**96 * 32!, mutta yhä tekoälyltä on huomaamatta, että Z:sta käytetään vai 20 eikä 32 bittiä.

Mitä pidempään keskustelet tekoälyn kanssa, sen vähemmän se "muistaa" tuota alkuperäistä koodia, ja vastaukset menevät vähitellen entistä pahemmin metsään.

Ei kannata kopioida keskusteluja tänne, koska niitä ei pysty täällä seuraamaan, kun ainakin potenssimerkinnät katoavat. (Esim. 2240 pitäisi olla 2**(2**40), missä ** on potenssimerkintä.)

jone2712 [21.04.2025 21:05:33]

#

Tuollainen main tutkii, kuinka pitkiä pi-ketjuja löytyy:

int main(void)
{
    char *pi="1415926535897932384626433832795028841971693993751058209749445923";
    unsigned maxKpl=0, i=0;
    double loop=0;
    xxcx F;

    for (;; loop+=1.0)
    {
        int x=F.rnd(10)+(int)'0';
        if ((char)x==*(pi+i))
        {
            ++i;
        }
        else
        {
            if (i>maxKpl)
            {
                maxKpl=i;
                printf("pi %d numeron tarkkuudella\n", maxKpl);
                printf("loop=%0.0f\n\n", loop);
                i=0;
            }
            else i=0;
        }
    }
}

Tuloste on seuraavanlainen (ei jaksa odottaa kauemmin):

pi 1 numeron tarkkuudella
loop=8.00000000000000000000000

pi 2 numeron tarkkuudella
loop=17.00000000000000000000000

pi 4 numeron tarkkuudella
loop=675.00000000000000000000000

pi 5 numeron tarkkuudella
loop=24819.00000000000000000000000

pi 6 numeron tarkkuudella
loop=675892.00000000000000000000000

pi 8 numeron tarkkuudella
loop=23027338.00000000000000000000000

pi 9 numeron tarkkuudella
loop=1551096399.00000000000000000000000

pi 10 numeron tarkkuudella
loop=36590780678.00000000000000000000000

Sivun alkuun

Vastaus

Muista lukea kirjoitusohjeet.
Tietoa sivustosta