Mengapa XOR cara default untuk menggabungkan hash?

Katakanlah Anda memiliki dua hash H(A)dan H(B)dan Anda ingin menggabungkannya. Saya telah membaca bahwa cara yang baik untuk menggabungkan dua hash adalah dengan XORmereka, misalnya XOR( H(A), H(B) ).

Penjelasan terbaik yang saya temukan disentuh secara singkat di sini pada pedoman fungsi hash ini :

XORing dua angka dengan distribusi acak menghasilkan angka lain masih dengan distribusi acak *, tetapi yang sekarang tergantung pada dua nilai.
...
* Pada setiap bit dari dua angka untuk digabungkan, 0 adalah output jika kedua bit itu sama, atau 1. Dengan kata lain, dalam 50% dari kombinasi, 1 akan menjadi output. Jadi jika dua bit input masing-masing memiliki peluang sekitar 50-50 menjadi 0 atau 1, maka bit output juga akan.

Bisakah Anda menjelaskan intuisi dan / atau matematika di balik mengapa XOR harus menjadi operasi default untuk menggabungkan fungsi hash (daripada ATAU DAN DAN dll.)?

Dengan asumsi input acak seragam (1-bit), distribusi probabilitas output fungsi AND adalah 75% 0dan 25% 1. Sebaliknya, OR adalah 25% 0dan 75% 1.

Fungsi XOR adalah 50% 0dan 50% 1, oleh karena itu baik untuk menggabungkan distribusi probabilitas yang seragam.

Ini bisa dilihat dengan menuliskan tabel kebenaran:

 a | b | a AND b
---+---+--------
 0 | 0 |    0
 0 | 1 |    0
 1 | 0 |    0
 1 | 1 |    1

 a | b | a OR b
---+---+--------
 0 | 0 |    0
 0 | 1 |    1
 1 | 0 |    1
 1 | 1 |    1

 a | b | a XOR b
---+---+--------
 0 | 0 |    0
 0 | 1 |    1
 1 | 0 |    1
 1 | 1 |    0

Latihan: Berapa banyak fungsi logis dari dua input 1-bit adan bmemiliki distribusi output yang seragam ini? Mengapa XOR paling cocok untuk tujuan yang disebutkan dalam pertanyaan Anda?

xoradalah fungsi default berbahaya untuk digunakan saat hashing. Itu lebih baik daripada anddan or, tapi itu tidak banyak bicara.

xorsimetris, sehingga urutan unsur-unsurnya hilang. Jadi "bad"hash akan menggabungkan sama dengan "dab".

xor memetakan nilai identik berpasangan ke nol, dan Anda harus menghindari pemetaan nilai "umum" ke nol:

Jadi (a,a)dipetakan ke 0, dan (b,b)juga dipetakan ke 0. Karena pasangan seperti itu hampir selalu lebih umum daripada keacakan mungkin menyiratkan, Anda berakhir dengan banyak tabrakan jauh di nol dari yang seharusnya.

Dengan dua masalah ini, xorakhirnya menjadi hash combiner yang terlihat setengah layak di permukaan, tetapi tidak setelah pemeriksaan lebih lanjut.

Pada perangkat keras modern, menambahkan biasanya sekitar secepat xor(mungkin menggunakan lebih banyak daya untuk melakukan ini, diakui). Menambahkan tabel kebenaran mirip dengan xorpada bit yang dimaksud, tetapi juga mengirimkan sedikit ke bit berikutnya ketika kedua nilai adalah 1. Ini berarti ia menghapus lebih sedikit informasi.

Jadi hash(a) + hash(b)lebih baik daripada hash(a) xor hash(b)jika a==b, hasilnya hash(a)<<1bukan 0.

Ini tetap simetris; jadi "bad"dan"dab" mendapatkan hasil yang sama tetap menjadi masalah. Kami dapat memutus simetri ini dengan biaya sederhana:

hash(a)<<1 + hash(a) + hash(b)

alias hash(a)*3 + hash(b) . (menghitung hash(a)sekali dan menyimpan disarankan jika Anda menggunakan solusi shift). Konstanta ganjil mana pun alih-alih 3secara bijektif akan memetakan kbilangan bulat tak bertanda "-bit" ke dirinya sendiri, karena peta bilangan bulat tak bertanda adalah modulo matematika 2^kuntuk beberapak , dan konstanta ganjil apa pun relatif utama 2^k.

Untuk versi yang lebih keren, kita dapat memeriksa boost::hash_combine, yang secara efektif:

size_t hash_combine( size_t lhs, size_t rhs ) {
  lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
  return lhs;
}

di sini kami menambahkan bersama beberapa versi bergeser dari seed dengan konstanta (yang pada dasarnya acak 0s dan 1s - khususnya itu adalah kebalikan dari rasio emas sebagai fraksi titik tetap 32 bit) dengan beberapa tambahan dan xor. Ini memecah simetri, dan memperkenalkan beberapa "noise" jika nilai hash yang masuk buruk (yaitu, bayangkan setiap komponen hash ke 0 - di atas menanganinya dengan baik, menghasilkan noda 1dan0 s setelah masing-masing digabungkan. Naif saya 3*hash(a)+hash(b)hanya menghasilkan a 0di kasus itu).

(Bagi mereka yang tidak terbiasa dengan C / C ++, a size_t adalah nilai integer yang tidak ditandatangani yang cukup besar untuk menggambarkan ukuran objek apa pun dalam memori. Pada sistem 64 bit, biasanya integer 64 bit yang tidak ditandai. Pada sistem 32 bit , bilangan bulat 32 bit unsigned.)

Terlepas dari sifat pencampuran bitnya yang praktis, XOR tidak cara yang baik untuk menggabungkan hash karena sifatnya yang komutatif. Pertimbangkan apa yang akan terjadi jika Anda menyimpan permutasi {1, 2, ..., 10} dalam tabel hash dengan 10-tupel.

Pilihan yang jauh lebih baik adalah m * H(A) + H(B), di mana m adalah angka ganjil yang besar.

Credit: Combiner di atas adalah tip dari Bob Jenkins.

Xor mungkin merupakan cara "default" untuk menggabungkan hash tetapi jawaban Greg Hewgill juga menunjukkan mengapa ia memiliki jebakan: Xor dari dua nilai hash yang identik adalah nol. Dalam kehidupan nyata, ada hash yang identik lebih umum daripada yang diperkirakan. Anda kemudian mungkin menemukan bahwa dalam kasus-kasus sudut (tidak begitu jarang) ini, hash gabungan yang dihasilkan selalu sama (nol). Tabrakan hash akan jauh, jauh lebih sering daripada yang Anda harapkan.

Dalam contoh yang dibuat-buat, Anda mungkin menggabungkan kata sandi hash dari pengguna dari berbagai situs web yang Anda kelola. Sayangnya, sejumlah besar pengguna menggunakan kembali kata sandi mereka, dan proporsi yang mengejutkan dari hash yang dihasilkan adalah nol!

Ada sesuatu yang ingin saya tunjukkan secara eksplisit untuk orang lain yang menemukan halaman ini. DAN dan ATAU membatasi keluaran seperti BlueRaja - Danny Pflughoe berusaha menunjukkan, tetapi dapat didefinisikan dengan lebih baik:

Pertama saya ingin mendefinisikan dua fungsi sederhana yang akan saya gunakan untuk menjelaskan ini: Min () dan Max ().

Min (A, B) akan mengembalikan nilai yang lebih kecil antara A dan B, misalnya: Min (1, 5) mengembalikan 1.

Max (A, B) akan mengembalikan nilai yang lebih besar antara A dan B, misalnya: Max (1, 5) mengembalikan 5.

Jika Anda diberikan: C = A AND B

Maka Anda dapat menemukannya C <= Min(A, B) Kami tahu ini karena tidak ada yang dapat Anda DAN dengan 0 bit A atau B untuk menjadikannya 1s. Jadi setiap bit nol tetap merupakan bit nol dan setiap bit memiliki peluang untuk menjadi bit nol (dan dengan demikian nilai yang lebih kecil).

Dengan: C = A OR B

Yang sebaliknya adalah benar: C >= Max(A, B)Dengan ini, kita melihat konsekuensi wajar untuk fungsi AND. Setiap bit yang sudah menjadi satu tidak bisa ORed menjadi nol, jadi itu tetap satu, tetapi setiap bit nol memiliki kesempatan untuk menjadi satu, dan dengan demikian jumlah yang lebih besar.

Ini menyiratkan bahwa keadaan input berlaku pembatasan pada output. Jika Anda DAN apa pun dengan 90, Anda tahu output akan sama dengan atau kurang dari 90 terlepas dari apa nilai lainnya.

Untuk XOR, tidak ada batasan tersirat berdasarkan input. Ada kasus-kasus khusus di mana Anda dapat menemukan bahwa jika Anda XOR byte dengan 255 daripada Anda mendapatkan kebalikannya, tetapi byte yang mungkin dapat dihasilkan dari itu. Setiap bit memiliki kesempatan untuk mengubah status tergantung pada bit yang sama di operan lainnya.

Jika Anda XORinput acak dengan input bias, outputnya acak. Hal yang sama tidak berlaku untuk ANDatau OR. Contoh:

00101001 XOR 00000000 = 00101001
00101001 DAN 00000000 = 00000000
00101001 ATAU 11111111 = 11111111

Seperti @Greg Hewgill menyebutkan, bahkan jika kedua input tersebut acak, menggunakan ANDatau ORakan menghasilkan output yang bias.

Alasan kami menggunakan XORlebih dari sesuatu yang lebih kompleks adalah, yah, tidak perlu: XORbekerja dengan sempurna, dan sangat cepat.

Tutupi 2 kolom kiri dan coba cari tahu apa input menggunakan hanya output.

 a | b | a AND b
---+---+--------
 0 | 0 |    0
 0 | 1 |    0
 1 | 0 |    0
 1 | 1 |    1

Ketika Anda melihat 1-bit, Anda seharusnya mengetahui bahwa kedua input tersebut adalah 1.

Sekarang lakukan hal yang sama untuk XOR

 a | b | a XOR b
---+---+--------
 0 | 0 |    0
 0 | 1 |    1
 1 | 0 |    1
 1 | 1 |    0

XOR tidak memberikan apa-apa tentang itu input.

Kode sumber untuk berbagai versi hashCode()di java.util.Arrays adalah referensi yang bagus untuk algoritma hashing yang umum digunakan. Mereka mudah dipahami dan diterjemahkan ke dalam bahasa pemrograman lain.

Secara kasar, sebagian besar hashCode()implementasi multi-atribut mengikuti pola ini:

public static int hashCode(Object a[]) {
    if (a == null)
        return 0;

    int result = 1;

    for (Object element : a)
        result = 31 * result + (element == null ? 0 : element.hashCode());

    return result;
}

Anda dapat mencari Tanya Jawab StackOverflow lainnya untuk informasi lebih lanjut tentang keajaiban di baliknya 31, dan mengapa kode Java sering menggunakannya. Tidak sempurna, tetapi memiliki karakteristik kinerja umum yang sangat baik.

XOR tidak mengabaikan beberapa input terkadang seperti OR dan AND .

Jika Anda mengambil AND (X, Y) misalnya, dan memasukkan input X dengan false, maka input Y tidak masalah ... dan orang mungkin ingin input menjadi masalah saat menggabungkan hash.

Jika Anda mengambil XOR (X, Y) maka KEDUA masukan SELALU penting. Tidak akan ada nilai X di mana Y tidak masalah. Jika X atau Y diubah maka output akan mencerminkan itu.