GUIDが一意でないことの簡単な証明[終了]

GUIDが単純なテストプログラムで一意でないことを証明したいと思います。次のコードは何時間も実行されると思っていましたが、機能していません。どうすれば機能させることができますか？

BigInteger begin = new BigInteger((long)0);
BigInteger end = new BigInteger("340282366920938463463374607431768211456",10);  //2^128
for(begin; begin<end; begin++)
  Console.WriteLine(System.Guid.NewGuid().ToString());

C＃を使用しています。

カイ、私はあなたがスレッドを使ってあなたが望むことをするプログラムを提供しました。これは、次の条件でライセンスされています。実行するCPUコアごとに1時間あたり$ 0.0001を支払う必要があります。料金は各月末に支払われます。できるだけ早くペイパルアカウントの詳細をご連絡ください。

using System;
using System.Collections.Generic;
using System.Linq;

namespace GuidCollisionDetector
{
    class Program
    {
        static void Main(string[] args)
        {
            //var reserveSomeRam = new byte[1024 * 1024 * 100];     // This indeed has no effect.

            Console.WriteLine("{0:u} - Building a bigHeapOGuids.", DateTime.Now);
            // Fill up memory with guids.
            var bigHeapOGuids = new HashSet<Guid>();
            try
            {
                do
                {
                    bigHeapOGuids.Add(Guid.NewGuid());
                } while (true);
            }
            catch (OutOfMemoryException)
            {
                // Release the ram we allocated up front.
                // Actually, these are pointless too.
                //GC.KeepAlive(reserveSomeRam);
                //GC.Collect();
            }
            Console.WriteLine("{0:u} - Built bigHeapOGuids, contains {1} of them.", DateTime.Now, bigHeapOGuids.LongCount());


            // Spool up some threads to keep checking if there's a match.
            // Keep running until the heat death of the universe.
            for (long k = 0; k < Int64.MaxValue; k++)
            {
                for (long j = 0; j < Int64.MaxValue; j++)
                {
                    Console.WriteLine("{0:u} - Looking for collisions with {1} thread(s)....", DateTime.Now, Environment.ProcessorCount);
                    System.Threading.Tasks.Parallel.For(0, Int32.MaxValue, (i) =>
                    {
                        if (bigHeapOGuids.Contains(Guid.NewGuid()))
                            throw new ApplicationException("Guids collided! Oh my gosh!");
                    }
                    );
                    Console.WriteLine("{0:u} - That was another {1} attempts without a collision.", DateTime.Now, ((long)Int32.MaxValue) * Environment.ProcessorCount);
                }
            }
            Console.WriteLine("Umm... why hasn't the universe ended yet?");
        }
    }
}

PS：Parallel extensionsライブラリを試してみたかった。それは簡単でした。

そして、制御フローとしてOutOfMemoryExceptionを使用すると、間違っているように感じます。

編集

まあ、これはまだ投票を集めているようです。そこで、GC.KeepAlive（）の問題を修正しました。そして、C＃4で実行するように変更しました。

そして、私のサポート条件を明確にするために：サポートは2010年2月28日でのみ利用可能です。タイムマシンで当日のみサポートをお願いします。

編集2 いつものように、GCはメモリの管理で私よりも優れています。それを自分でやろうとした以前の試みは失敗する運命にありました。

これは何時間も実行されます。1 GHzでループする（そうならない-それよりもはるかに遅い）と仮定すると、10790283070806014188970年間動作します。これは宇宙の時代の約830億倍長いです。

ムーアの法則が成立すると仮定すると、このプログラムを実行せずに数百年待って、何十億倍も速いコンピューターで実行するほうがはるかに速くなります。実際、CPU速度が2倍になる（約18か月）よりも実行に時間がかかるプログラムは、CPU速度が上がるまで待ってから新しいCPUを購入してから実行すると、完了までの時間が短くなります。新しいハードウェアで一時停止および再開できます）。

GUIDは理論的には一意ではありません。ここにあなたの証拠があります：

• GUIDは128ビットの数値です
• 古いGUIDを再利用せずに2 ^ 128 + 1以上のGUIDを生成することはできません

ただし、太陽の出力全体がこのタスクの実行に向けられている場合は、完了する前に冷たくなります。

GUIDは、いくつかの異なる手法を使用して生成できます。その一部は、特定のマシンが同じGUIDを2回生成しないことを保証するために特別な措置をとります。特定のアルゴリズムで衝突を検出すると、GUIDを生成するための特定の方法が不適切であることが示されますが、GUIDについては一般的に何も証明されません。

もちろん、GUIDは衝突する可能性があります。GUIDは128ビットなので2^128 + 1、それらを生成し、鳩の巣の原理で衝突が発生するはずです。

ただし、GUIDが一意であると言う場合、実際に意味するのは、キースペースが非常に大きいため、誤って同じGUIDを2回生成することは事実上不可能であるということです（GUIDをランダムに生成していると仮定します）。

nGUIDのシーケンスをランダムに生成する場合、少なくとも1つの衝突の可能性はおよそですp(n) = 1 - exp(-n^2 / 2 * 2^128)（これは、可能な誕生日の数がである誕生日の問題2^128です）。

   n     p(n)
2^30 1.69e-21
2^40 1.77e-15
2^50 1.86e-10
2^60 1.95e-03

これらの数字は、コンクリートにするために、2^60 = 1.15e+18。したがって、毎秒10億のGUIDを生成する場合、2^60ランダムなGUID を生成するのに36年かかり、それでも衝突が発生する確率は変わりません1.95e-03。次の36年間で衝突を見つけるよりも、人生のある時点で殺される可能性が高くなります（4.76e-03）。幸運を。

一意性が心配な場合は、常に新しいGUIDを購入して、古いGUIDを捨てることができます。よろしければ、eBayに出品します。

個人的には、2つのGUIDが衝突したときに「ビッグバン」が発生したと思います。

量子ボゴソートアルゴリズムのバリアントを使用して、O（1）時間でそれを示すことができます。

Guid g1 = Guid.NewGuid();
Guid g2 = Guid.NewGuid();
if(g1 != g2) Universe.Current.Destroy();

任意の2つのGUIDが一意である可能性が非常に高い（等しくない）。

このSOエントリ、およびWikipediaを参照してください

生成された各GUIDが一意であるとは限りませんが、一意のキーの総数（2 ^ 128または3.4×10 ^ 38）は非常に多いため、同じ番号が2回生成される確率は非常に小さくなります。たとえば、約5×10 ^ 22の星を含む観測可能な宇宙を考えてみましょう。すべてのスターは6.8×10 ^ 15の普遍的に一意のGUIDを持つことができます。

したがって、おそらく何十億年も待つ必要があり、宇宙が終わる前に宇宙に到達することを願っています。

[更新：] 以下のコメントが指摘するように、新しいMS GUIDはV4であり、GUID生成の一部としてMACアドレスを使用しません（ただし、MSからのV5実装の兆候は見たことがありません。リンクを確認してください）。ただし、V4を使用しても、時間は依然として重要な要素であり、GUIDの重複に対する確率は非常に小さいため、実際の使用には関係ありません。OPが実行しようとしたような単一のシステムテストから重複したGUIDを生成することはおそらくありません。

これらの回答のほとんどには、MicrosoftのGUID実装に関する重要な点が1つありません。GUIDの最初の部分はタイムスタンプに基づいており、別の部分はネットワークカードのMACアドレス（またはNICがインストールされていない場合は乱数）に基づいています。

これを正しく理解していれば、GUIDを複製する唯一の信頼できる方法は、MACアドレスが同じで、両方のシステムのクロックが生成時に同じ時刻であった複数のマシンで同時にGUID生成を実行することであることを意味します発生しました（タイムスタンプは、正しく理解していればミリ秒に基づいています）...それでも、ランダムな数のビットが他にもたくさんあるので、オッズはまだほとんどありません。

すべての実用的な目的で、GUIDは普遍的に一意です。

"The Old New Thing"ブログには、MS GUIDに関するかなり良い説明があります。

コードの多くの場所でGUIDの一意性を確認する場合に使用できる、気の利いた小さな拡張メソッドを次に示します。

internal static class GuidExt
{
    public static bool IsUnique(this Guid guid)
    {
        while (guid != Guid.NewGuid())
        { }
        return false;
    }
}

それを呼び出すには、新しいGUIDを生成するたびに、Guid.IsUniqueを呼び出すだけです...

Guid g = Guid.NewGuid();
if (!g.IsUnique())
{
    throw new GuidIsNotUniqueException();
}

...一体、最初のラウンドで正しく機能することを確認するために、2回呼び出すことをお勧めします。

2 ^ 128に数えます-野心的です。

ではない-私たちはマシンごとに毎秒2 ^ 32のIDを数えることができることを想像することができますことを野心的な、それは毎秒さえ43億ではないからです。そのタスクに2 ^ 32マシンを割り当てましょう。さらに、それぞれに2 ^ 32の文明を取得して、同じリソースをタスクに割り当てます。

これまでのところ、1秒あたり2 ^ 96のIDをカウントできます。つまり、2 ^ 32秒（136年を少し超える）をカウントすることになります。

ここで必要なのは、4,294,967,296の文明を各専用の4,294,967,296のマシンに取得することだけです。各マシンは、毎秒4,294,967,296のIDをカウントすることができ、純粋に次の136年間このタスクを実行できます。この重要なタスクを今すぐ始めることをお勧めします。 -）

830億年の実行時間が怖くない場合は、生成されたGUIDをどこかに保存して、重複がないかどうかを確認する必要があると考えてください。2 ^ 128の16バイトの数値を保存する場合は、事前に4951760157141521099596496896テラバイトのRAMを割り当てるだけでよいので、それらすべてに対応できるコンピュータがあり、テラバイトのDIMMをそれぞれ10グラムで購入する場所を見つけたら、それらを合計すると地球の質量が8を超えるため、「実行」を押す前に、現在の軌道から真剣にシフトすることができます。考え直してください！

for(begin; begin<end; begin)
    Console.WriteLine(System.Guid.NewGuid().ToString());

あなたはインクリメントしていないbeginので、条件begin < endは常に真です。

GUIDの衝突が懸念される場合は、代わりにScottGuIDを使用することをお勧めします。

おそらく、Guidsを生成するアルゴリズムが真に乱数を生成するのではなく、実際に<< 2 ^ 128の周期で循環していると信じる理由があると思います。

たとえば、一部のビットの値を修正するGUIDを導出するために使用されるRFC4122メソッド。

サイクリングの証拠は、期間の可能なサイズによって異なります。

短い期間の場合、hash（GUID）のハッシュテーブル-> GUIDが一致しない場合に衝突時に置き換えられるGUID（一致する場合は終了する）のアプローチが考えられます。また、ランダムな時間の交換のみを行うことも検討してください。

最終的に、衝突の最大期間が十分に長い場合（事前にわかっていない場合）、どの方法でも、衝突が存在した場合に衝突が見つかる可能性があります。

GUIDの生成方法がクロックベースの場合（RFCを参照）、衝突が存在するかどうかを判断できない場合があることに注意してください。または（b）クロックティック内で衝突を強制するのに十分なGUIDを要求できない。

あるいは、Guid内のビット間の統計的関係、またはGuid間のビットの相関を示すことができる場合があります。このような関係により、実際の衝突を見つけることができない場合でも、アルゴリズムに欠陥がある可能性が高くなります。

もちろん、Guidsが衝突する可能性があることを証明したいだけなら、プログラムではなく数学的証明が答えです。

グラフィックカードのアップグレードについて誰も言及しなかった理由がわかりません...確かにハイエンドのNVIDIA Quadro FX 4800か何か（192 CUDAコア）を手に入れたら、これはもっと速くなるでしょう...

もちろん、NVIDIA Qadro Plex 2200 S4を（それぞれ960 CUDAコアで）数台購入できる場合、この計算は実際にます。おそらく、NVIDIAは、PRスタントとして「テクノロジーデモンストレーション」のためにいくつかを貸してくれるでしょうか？

きっと彼らはこれに参加したいと思うでしょう 歴史的な計算の ...

しかし、あなたはあなたがあなたが複製を持っていることを確認する必要がありますか、それともそこにある場合にのみ気にしますかする可能性がある同じ誕生日の人が2人いることを確認するには、366人（うるう年を除く）が必要です。2人が同じ誕生日を迎える可能性が50％を超える場合、必要なのは23人だけです。それが誕生日の問題ですです。

32ビットの場合、重複の可能性が50％を超えるのに必要な値は77,163のみです。やってみよう：

Random baseRandom = new Random(0);

int DuplicateIntegerTest(int interations)
{
    Random r = new Random(baseRandom.Next());
    int[] ints = new int[interations];
    for (int i = 0; i < ints.Length; i++)
    {
        ints[i] = r.Next();
    }
    Array.Sort(ints);
    for (int i = 1; i < ints.Length; i++)
    {
        if (ints[i] == ints[i - 1])
            return 1;
    }
    return 0;
}

void DoTest()
{
    baseRandom = new Random(0);
    int count = 0;
    int duplicates = 0;
    for (int i = 0; i < 1000; i++)
    {
        count++;
        duplicates += DuplicateIntegerTest(77163);
    }
    Console.WriteLine("{0} iterations had {1} with duplicates", count, duplicates);
}

1000 iterations had 737 with duplicates

今では128ビットはたくさんあります、それであなたはまだあなたに衝突の低い可能性をまだ与えている多くのアイテムを話している。概算を使用して、指定されたオッズに対して次の数のレコードが必要になります。

• 衝突が発生する1/1000の確率で8億
• 衝突が発生する確率が50％の場合、217億
• 衝突が発生する確率が90％の場合は396億

毎年約1E14の電子メールが送信されるため、同じレベルのGUIDを2つ持つ確率が90％になる前に、このレベルでは約400,000年になります。宇宙の時代の何倍か、または複製が見つかる前に太陽が冷えてしまうこと。

あなた方全員が重要なポイントを見逃していませんか？

GUIDは2つのものを使用して生成されたため、グローバルに一意である可能性が非常に高くなると思いました。1つは、使用しているマシンのMACアドレスがシードされ、2つは生成された時間と乱数を使用することです。

したがって、実際のマシンでそれを実行し、マシンがGUIDで時間を表すために使用する最小時間内にすべての推測を実行しない限り、システムコールを使用して何回推測しても、同じ数は生成されません。

実際にGUIDを作成する方法を知っていると、推測にかかる時間が大幅に短縮されると思います。

トニー

GUIDをハッシュできます。そうすれば、はるかに速く結果が得られるはずです。

もちろん、複数のスレッドを同時に実行することもお勧めです。これにより、異なるスレッドで同じGUIDが2回生成されて競合状態が発生する可能性が高まります。

4ビットはバージョン番号を保持するため、GUIDは124ビットです。

1. ニューヨーク市の極低温研究所に行きます。
2. （大体）1990年間フリーズします。
3. Planet Expressに就職しましょう。
4. 新品のCPUを購入します。コンピューターを構築し、プログラムを実行し、終末機のような疑似永久運動機で安全な場所に置きます。
5. タイムマシンが発明されるまで待ちます。
6. タイムマシンを使用して未来にジャンプします。1YHz 128bit CPUを購入した場合は、3,938,453,320 days 20 hours 15 minutes 38 seconds 463 ms 463 μs 374 ns 607 psた場合は、プログラムの実行を開始した後にます。
7. ...？
8. 利益!!!

... 10,783,127CPUが1YHzの場合でも、少なくとも数年はかかります1,000,000,000,000,000（または1,125,899,906,842,624バイナリプレフィックスを使用したい場合）、1GHz CPUよりも高速であるます。

ですから、コンピューティングが完了するのを待つよりも、家を失ったハトに餌をあげた方がいいでしょう。 nハトが。:(

または、128ビットの量子コンピューターが発明されるまで待つこともできます。次に、妥当な時間内にプログラムを使用することにより、GUIDが一意でないことを証明できます（たぶん）。

begin = begin + new BigInteger((long)1)begin ++の代わりに試しましたか？

生成されるUUIDの数がムーアの法則に従う場合、予見可能な将来にGUIDが不足しないという印象は誤りです。

2 ^ 128 UUIDの場合、すべてのUUIDが不足するまでに18か月* Log2（2 ^ 128）〜= 192年しかかかりません。

そして、UUIDが大量に採用されてからの過去数年の間に（統計的証拠はまったくありませんが）、ムーアの法則よりもUUIDの生成速度が速くなっていると思います。言い換えると、UUID危機に対処する必要があるまで、おそらく192年未満です。それは、宇宙の終わりよりはるかに早いです。

しかし、2012年末までに枯渇することは絶対にないので、問題を心配するために他の種に任せます。

GUID生成コードのバグの確率は、衝突を生成するアルゴリズムの確率よりもはるかに高いです。GUIDをテストするコードのバグの可能性はさらに高くなります。あきらめる。

プログラムは、エラーではありますが、GUIDが一意ではないことの証拠を示しています。反対を証明しようとする人々は要点を逃しています。このステートメントは、GUIDバリエーションの一部の弱い実装を証明するだけです。

GUIDは、定義によって一意である必要はありません。定義によって高度に一意です。あなたは非常に意味を洗練させました。バージョン、実装者（MSなど）、VMの使用などに応じて、定義が大きく変わります。（以前の投稿のリンクを参照）

あなたのポイントを証明するために128ビットのテーブルを短くすることができます。最良の解決策は、ハッシュ式を使用して重複するテーブルを短くし、ハッシュが衝突してGUIDを再生成したら、完全な値を使用することです。別の場所から実行している場合は、ハッシュ/フルキーのペアを中央の場所に保存します。

Ps：x個の異なる値を生成するだけの場合は、この幅のハッシュテーブルを作成し、ハッシュ値を確認します。

ここで焚き火をしているわけではありませんが、実際に起こります、そして、はい、あなたがこの男に与えている冗談を理解しましたが、GUIDは原則的に一意であり、バグがあるため、このスレッドにぶつかりましたWP7エミュレータでは、起動するたびに最初に呼び出されたときに同じGUIDが表示されます！したがって、理論的には競合が発生しない場合、前述のGUIの生成に問題があると、重複が発生する可能性があります。

http://forums.create.msdn.com/forums/p/92086/597310.aspx#597310

Guid生成の一部は現在のマシンの時間に基づいているため、複製のGuidを取得するための私の理論は次のとおりです。

1. Windowsのクリーンインストールを実行する
2. Windowsが起動するときと同様に、時刻を2010-01-01 12:00:00にリセットする起動スクリプトを作成します。
3. 起動スクリプトの直後に、アプリケーションがトリガーされてGUIDが生成されます。
4. このWindowsインストールのクローンを作成して、後続の起動で発生する可能性のある微妙な違いを除外します。
5. このイメージでハードドライブのイメージを再作成し、マシンを数回起動します。

私にとって、単一のコアがUUIDv1を生成するのにかかる時間は、それが一意であることを保証します。マルチコアの状況でも、UUIDジェネレーターが特定のリソースに対して一度に1つのUUIDのみを生成できる場合（リソースは本質的にアドレスの一部であるため、複数のリソースが同じUUIDを完全に利用できることに注意してください）タイムスタンプが切れるまで持続するのに十分なUUIDを持っています。その時点で私はあなたが気にかけることを本当に疑います。

これも解決策です：

int main()
{
  QUuid uuid;
  while ( (uuid = QUuid::createUuid()) != QUuid::createUuid() ) { }
  std::cout << "Aha! I've found one! " << qPrintable( uuid.toString() ) << std::endl;
}

注：Qtが必要ですが、十分に長く実行すると、Qtが見つかるかもしれません。

（注：実際、私がそれを見ている今、生成アルゴリズムについて、後で生成される2つのuuidが衝突するのを防ぐ何かがあるかもしれませんが、ちょっと疑わしいです）。

GUIDが一意でないことを証明する唯一の解決策は、ワールドGUIDプールを持つことです。GUIDがどこかで生成されるたびに、組織に登録する必要があります。あるいは、すべてのGUIDジェネレータがそれを自動的に登録する必要があり、そのためにアクティブなインターネット接続が必要であるという標準化を含めるかもしれません！