<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="ru">
		<id>http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Kuro</id>
		<title>Викиконспекты - Вклад участника [ru]</title>
		<link rel="self" type="application/atom+xml" href="http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Kuro"/>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F:%D0%92%D0%BA%D0%BB%D0%B0%D0%B4/Kuro"/>
		<updated>2026-08-04T13:36:23Z</updated>
		<subtitle>Вклад участника</subtitle>
		<generator>MediaWiki 1.30.0</generator>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50917</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50917"/>
				<updated>2016-01-08T16:33:53Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition='''Вероятностное множество''' (англ. ''probabilistic set'') {{---}} структура данных, способная добавлять элемент в множество, а также выполнять запросы проверки принадлежности элемента множеству. При этом существует возможность получить или положительный, но неопределенный ответ (элемента в множестве нет, но структура данных сообщает, что он есть), или отрицательный определенный ответ (элемент точно не содержится в данном множестве).&lt;br /&gt;
}}&lt;br /&gt;
Неформально вероятностное множество {{---}} это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;p(h_i(x) \neq j) = 1 - \dfrac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex &amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \dfrac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;(1 - \dfrac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex &amp;gt;(1 - \dfrac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;k = \ln 2 \dfrac {m}{n} \approx 0.6931 \dfrac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примеры реализации фильтра Блума ==&lt;br /&gt;
В ответ на запрос поиска есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
*Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску,&lt;br /&gt;
*компьютерные программы для проверки орфографии,&lt;br /&gt;
*Bitcoin&amp;lt;ref&amp;gt;[https://en.wikipedia.org/wiki/Bitcoin Wikipedia {{---}} Bitcoin]&amp;lt;/ref&amp;gt; использует фильтр Блума, чтобы ускорить синхронизацию с кошельком. &lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50916</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50916"/>
				<updated>2016-01-08T16:31:36Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition='''Вероятностное множество''' (англ. ''probabilistic set'') {{---}} структура данных, способная добавлять элемент в множество, а также выполнять запросы запросы проверки принадлежности элемента множеству. При этом существует возможность получить или положительный, но неопределенный ответ (элемента в множестве нет, но структура данных сообщает, что он есть), или отрицательный определенный ответ (элемент точно не содержится в данном множестве).&lt;br /&gt;
}}&lt;br /&gt;
Неформально вероятностное множество {{---}} это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;p(h_i(x) \neq j) = 1 - \dfrac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex &amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \dfrac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;(1 - \dfrac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex &amp;gt;(1 - \dfrac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex&amp;gt;k = \ln 2 \dfrac {m}{n} \approx 0.6931 \dfrac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примеры реализации фильтра Блума ==&lt;br /&gt;
В ответ на запрос поиска есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
*Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску,&lt;br /&gt;
*компьютерные программы для проверки орфографии,&lt;br /&gt;
*Bitcoin&amp;lt;ref&amp;gt;[https://en.wikipedia.org/wiki/Bitcoin Wikipedia {{---}} Bitcoin]&amp;lt;/ref&amp;gt; использует фильтр Блума, чтобы ускорить синхронизацию с кошельком. &lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50915</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50915"/>
				<updated>2016-01-08T16:12:45Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition='''Вероятностное множество'''(англ. ''probabilistic set'') {{---}} структура данных, способная добавлять элемент в множество и способная также выполнять запросы поиска в заданном множестве. При этом существует возможность получить или положительный ,но неопределенный ответ (элемента в множестве нет, но структура данных сообщает, что он есть), или отрицательный определенный ответ (элемент точно не содержится в данном множестве).&lt;br /&gt;
}}&lt;br /&gt;
Неформально вероятностное множество {{---}} это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
'''Фильтр Блума'''(англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \dfrac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \dfrac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;k = \ln 2 \dfrac {m}{n} \approx 0.6931 \dfrac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примеры реализации фильтра Блюма ==&lt;br /&gt;
В ответ на запрос поиска есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
*Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску,&lt;br /&gt;
*Компьютерные программы для проверки орфографии,&lt;br /&gt;
*Bitcoin&amp;lt;ref&amp;gt;[https://en.wikipedia.org/wiki/Bitcoin Wikipedia {{---}} Bitcoin]&amp;lt;/ref&amp;gt; использует фильтр Блюма, чтобы ускорить синхронизацию с кошельком. &lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50914</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50914"/>
				<updated>2016-01-08T16:11:26Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition='''Вероятностное множество''' {{---}} структура данных, способная добавлять элемент в множество и способная также выполнять запросы поиска в заданном множестве. При этом существует возможность получить или положительный ,но неопределенный ответ (элемента в множестве нет, но структура данных сообщает, что он есть), или отрицательный определенный ответ (элемент точно не содержится в данном множестве).&lt;br /&gt;
}}&lt;br /&gt;
Неформально вероятностное множество {{---}} это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
'''Фильтр Блума'''(англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \dfrac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \dfrac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;k = \ln 2 \dfrac {m}{n} \approx 0.6931 \dfrac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примеры реализации фильтра Блюма ==&lt;br /&gt;
В ответ на запрос поиска есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
*Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску,&lt;br /&gt;
*Компьютерные программы для проверки орфографии,&lt;br /&gt;
*Bitcoin&amp;lt;ref&amp;gt;[https://en.wikipedia.org/wiki/Bitcoin Wikipedia {{---}} Bitcoin]&amp;lt;/ref&amp;gt; использует фильтр Блюма, чтобы ускорить синхронизацию с кошельком. &lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=Quotient_filter&amp;diff=50913</id>
		<title>Quotient filter</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=Quotient_filter&amp;diff=50913"/>
				<updated>2016-01-08T15:42:40Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Quotient filter''' {{---}} [[Фильтр_Блума#Определение|вероятностное множество]].&lt;br /&gt;
&lt;br /&gt;
Существует связь между размером хранилища и шансом ложноположительного срабатывания. Поддерживаются операции добавления нового элемента в множество. С увеличением размера хранимого множества повышается вероятность ложного срабатывания. &lt;br /&gt;
Структуру разработал Michael Bender в 2011 году&amp;lt;ref&amp;gt;Bender, Michael A.; Farach-Colton, Martin; Johnson, Rob; Kuszmaul, Bradley C.; Medjedovic, Dzejla; Montes, Pablo; Shetty, Pradeep; Spillane, Richard P.; Zadok, Erez (June 2011).[http://vldb.org/pvldb/vol5/p1627_michaelabender_vldb2012.pdf &amp;quot;Don't thrash: how to cache your hash on flash&amp;quot; (PDF)]&amp;lt;/ref&amp;gt; как замена [[:Фильтр_Блума|фильтра Блума]]. Фильтр используется для ускорения ответов в хранилище ключ-значение.  &lt;br /&gt;
&lt;br /&gt;
==Описание структуры данных==&lt;br /&gt;
[[Файл:filter.png|400px|thumb|right|Фильтр используется для ускорения ответов в хранилище ключ-значение. Пары ключ-значение содержатся в хранилище с медленным доступом. Фильтр отфильтровывает ненужные запросы в хранилище (запрос ключа которого точно нет в хранилище), что ускоряет его работу вцелом, но увеличевает потребление памяти]]&lt;br /&gt;
&lt;br /&gt;
В quotient filter хеш-функция возвращает &amp;lt;tex&amp;gt;p&amp;lt;/tex&amp;gt; битовый хеш, последние &amp;lt;tex&amp;gt;r&amp;lt;/tex&amp;gt; бит которого называются '''остатком''' (англ. ''remainder''), а &amp;lt;tex&amp;gt;q = p - r&amp;lt;/tex&amp;gt; старших бит называются '''частным''' (англ. ''quotient''), отсюда название структуры quotient filter&amp;lt;ref&amp;gt;Knuth, Donald (1973). The Art of Computer Programming:Searching and Sorting, volume 3. Section 6.4, exercise 13: Addison Wesley&amp;lt;/ref&amp;gt;. Фильтр представляет собой [[:Хеш-таблица|хеш-таблицу]], в которой харанится остаток и &amp;lt;tex&amp;gt;3&amp;lt;/tex&amp;gt; бита дополнительной информации (удобно хранить в целочисленном типе, используя &amp;lt;tex&amp;gt;3&amp;lt;/tex&amp;gt; старших бита под дополнительную информацию, а оставшиеся биты под остаток, накладывает ограничение на размер остатка). Биты дополнительной информации используются для разрешения ситуации, когда частное различных ключей указывает на одну ячейку в хеш-таблице. Размер хеш-таблицы составляет &amp;lt;tex&amp;gt;2^q&amp;lt;/tex&amp;gt;, так как есть всего &amp;lt;tex&amp;gt;2^q&amp;lt;/tex&amp;gt; разных частных.&lt;br /&gt;
&lt;br /&gt;
Пусть у нас есть ключ &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;, его хеш обозначим &amp;lt;tex&amp;gt;h(K)&amp;lt;/tex&amp;gt;, остаток &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt; и частное &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Попробуем поместить остаток в хеш-таблицу в ячейку с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;, называемую канонической. Возможно, ячейка уже занята, так как существует шанс полных коллизий (остаток и частное разных ключей совпадают) или частичных коллизий (частное разных ключей совпадают). &lt;br /&gt;
При полной коллизии мы получим ложноположительное срабатывание, но при частичной коллизии, с помощью дополнительных битов это избегается. Когда каноническая ячейка занята, помещаем остаток в какую-то ячейку справа. Этот способ решения колизий схож с [[:Разрешение_коллизий|линейным методом разрешения колизий]]. &lt;br /&gt;
&lt;br /&gt;
Последовательность ячеек, имеющих одинаковые частные называется '''пробегом''' (англ. ''run''). Возможно, что начало пробега не занимает канонический слот, если он уже занят каким-то другим пробегом.&lt;br /&gt;
&lt;br /&gt;
Пробег, у которого первый элемент занимает каноническую ячейку, является началом кластера. Кластер {{---}} объединение последовательных пробегов, концом кластера является пустая ячейка или начало другого кластера.&lt;br /&gt;
&lt;br /&gt;
Три дополнительных бита имеют следующие функции:&lt;br /&gt;
* бит занятости {{---}} равен единице, если ячейка является канонической для некого ключа в фильтре, сохраненого необязательно в этой ячейке,&lt;br /&gt;
* бит продолжения {{---}} равен единице, если ячейка занята, но не первым элементов пробеге,&lt;br /&gt;
* бит сдвига {{---}} равен единице, если пробег сдвинут относительно канонического слота.&lt;br /&gt;
&lt;br /&gt;
[[Файл:Quotient Filter.png|500px|thumb|right|Пример последовательной вставки элементов &amp;lt;tex&amp;gt; b, f, e, c, d, a&amp;lt;/tex&amp;gt;]]&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; border=1&lt;br /&gt;
|+&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#EEEEFF &lt;br /&gt;
! Бит занятости || Бит Продолжения || Бит сдвига || Описание &lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||0||0||style=&amp;quot;text-align:left;&amp;quot;|Пустая ячейка.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||0||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит начало пробега, сдвинутого относительно канонического слота.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||1||0||style=&amp;quot;text-align:left;&amp;quot;|Не используется. &lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||1||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит элемент пробега (не первый), сдвинутого относительно канонического слота.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||0||0||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит первый элемет пробега в его каноническом слоте.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||0||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит первый элемет пробега, сдвинутого относительно канонического слота. Ячейка является канонической, для существующего пробега сдвинутого вправо.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||1||0||style=&amp;quot;text-align:left;&amp;quot;|Не используется.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||1||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит элемент пробега (не первый), сдвинутого относительно канонического слота. Ячейка является канонической, для существующего пробега сдвинутого вправо.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
=== Поиск ===&lt;br /&gt;
&lt;br /&gt;
Пусть мы ищем ключ &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;. Смотрим в ячейку с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;, это каноническая ячейка для частного &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Если в этой ячейке бит занятости не единица, то элемент точно не содержится в множестве.&lt;br /&gt;
Если бит занятости единица, то нам нужно найти пробег для &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Так как начало нужного пробега может быть сдвинуто, найдем начало кластера. Идем влево от ячейки с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; и ищем первую с битом сдвига равным нулю, эта ячейка и будет началом кластера. Пока мы идем влево от ячейки с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; будем поддерживать счетчик, который бедет показывать сколько пробегов нам нужно будет пропустить от начала кластера. Каждая ячейка с битом занятости равным единице увеличивает счетчик на &amp;lt;tex&amp;gt;1&amp;lt;/tex&amp;gt;. После того как мы нашли начало кластера, пойдем от него влево, каждая ячейка с битом продолжения равным нулю говорит о завершении пробега, когда счетчик станет равным нулю мы найдем нужный нам пробег для частного &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Если в этом пробеге содержится &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt;, то &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;, вероятно, содержится в множестве, иначе &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt; точно не содержится в множестве.&lt;br /&gt;
&lt;br /&gt;
=== Вставка ===&lt;br /&gt;
&lt;br /&gt;
Аналогично с поиском: найдем позицию для &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt;, сдвигаем на одну позицию влево все эллементы кластера, начиная с выбранного, обновляем дополнительные биты. &lt;br /&gt;
&lt;br /&gt;
* Сдвиг не влияет на бит занятости. Выставляем бит занятости в ячейке &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; в единицу.&lt;br /&gt;
* Если мы вставляем &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt; в начало пробега, следовательно предыдущий элемент пробега стал вторым, у него нужно выставить бит продолжения.&lt;br /&gt;
* Мы выставляем бит сдвига в единицу для каждой ячейки, что мы сдвинули.&lt;br /&gt;
&lt;br /&gt;
== Преимущества ==&lt;br /&gt;
&lt;br /&gt;
* Последовательное расположение данных. Можно загружать только &amp;lt;tex&amp;gt;1&amp;lt;/tex&amp;gt; кластер, уменьшая количество кеш промахов.&lt;br /&gt;
* Простое увеличение или уменьшение хеш-таблицы, достаточно перенести один бит из остатка в частное или наоборот.&lt;br /&gt;
* Простое слияние двух фильтров.&lt;br /&gt;
&lt;br /&gt;
==См. также==&lt;br /&gt;
&lt;br /&gt;
*[[:Идеальное_хеширование|Идеальное хеширование]]&lt;br /&gt;
*[[:Универсальное_семейство_хеш-функций|Универсальное хеширование]]&lt;br /&gt;
&lt;br /&gt;
==Примечания==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации ==&lt;br /&gt;
&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Quotient_filter Wikipedia — Quotient filter]&lt;br /&gt;
* [http://habrahabr.ru/post/242285/  Habrahabr — Quotient filter]&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;br /&gt;
[[Категория: Структуры данных]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50912</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50912"/>
				<updated>2016-01-08T15:39:21Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition=Фильтр Блума (англ. ''Bloom filter'') является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также выполнять запросы поиска в заданном множестве. При этом существует возможность получить или положительный ,но неопределенный ответ (элемента в множестве нет, но структура данных сообщает, что он есть), или отрицательный определенный ответ (элемент точно не содержится в данном множестве).&lt;br /&gt;
}}&lt;br /&gt;
'''Фильтр Блума''' — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \dfrac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \dfrac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;k = \ln 2 \dfrac {m}{n} \approx 0.6931 \dfrac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество {{---}} это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50911</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50911"/>
				<updated>2016-01-08T15:38:36Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: по замечаниям&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition=Фильтр Блума (англ. ''Bloom filter'') является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также выполнять запросы поиска в заданном множестве. При этом существует возможность получить или положительный ,но неопределенный ответ (элемента в множестве нет, но структура данных сообщает, что он есть), или отрицательный определенный ответ(элемент точно не содержится в данном множестве).&lt;br /&gt;
}}&lt;br /&gt;
'''Фильтр Блума''' — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \dfrac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \dfrac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \dfrac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;k = \ln 2 \dfrac {m}{n} \approx 0.6931 \dfrac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество {{---}} это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50910</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50910"/>
				<updated>2016-01-08T15:17:23Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Вероятностное множество */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
{{Определение&lt;br /&gt;
|neat = 1 &lt;br /&gt;
|definition=Фильтр Блума является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также с некоторой вероятностью корректно отвечать на запрос о наличии элемента в множестве.&lt;br /&gt;
}}&lt;br /&gt;
В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество - это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50909</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50909"/>
				<updated>2016-01-08T15:07:18Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Вероятностное множество */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также с некоторой вероятностью корректно отвечать на запрос о наличии элемента в множестве. В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество - это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50908</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50908"/>
				<updated>2016-01-08T15:04:58Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также с некоторой вероятностью корректно отвечать на запрос о наличии элемента в множестве. В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable {{---}} Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество - это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Примечания ==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50907</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50907"/>
				<updated>2016-01-08T15:04:13Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Вероятностное множество */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также с некоторой вероятностью корректно отвечать на запрос о наличии элемента в множестве. В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable&amp;lt;ref&amp;gt;[https://cloud.google.com/bigtable {{---}} Google BigTable]&amp;lt;/ref&amp;gt; использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество - это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=Quotient_filter&amp;diff=50906</id>
		<title>Quotient filter</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=Quotient_filter&amp;diff=50906"/>
				<updated>2016-01-08T14:56:56Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Quotient filter''' {{---}} [[Фильтр_Блума#Вероятностное множество|вероятностная структура данных, позволяющая проверить принадлежность элемента множеству]].&lt;br /&gt;
&lt;br /&gt;
Существует связь между размером хранилища и шансом ложноположительного срабатывания. Поддерживаются операции добавления нового элемента в множество. С увеличением размера хранимого множества повышается вероятность ложного срабатывания. &lt;br /&gt;
Структуру разработал Michael Bender в 2011 году&amp;lt;ref&amp;gt;Bender, Michael A.; Farach-Colton, Martin; Johnson, Rob; Kuszmaul, Bradley C.; Medjedovic, Dzejla; Montes, Pablo; Shetty, Pradeep; Spillane, Richard P.; Zadok, Erez (June 2011).[http://vldb.org/pvldb/vol5/p1627_michaelabender_vldb2012.pdf &amp;quot;Don't thrash: how to cache your hash on flash&amp;quot; (PDF)]&amp;lt;/ref&amp;gt; как замена [[:Фильтр_Блума|фильтра Блума]]. Фильтр используется для ускорения ответов в хранилище ключ-значение.  &lt;br /&gt;
&lt;br /&gt;
==Описание структуры данных==&lt;br /&gt;
[[Файл:filter.png|400px|thumb|right|Фильтр используется для ускорения ответов в хранилище ключ-значение. Пары ключ-значение содержатся в хранилище с медленным доступом. Фильтр отфильтровывает ненужные запросы в хранилище (запрос ключа которого точно нет в хранилище), что ускоряет его работу вцелом, но увеличевает потребление памяти]]&lt;br /&gt;
&lt;br /&gt;
В quotient filter хеш-функция возвращает &amp;lt;tex&amp;gt;p&amp;lt;/tex&amp;gt; битовый хеш, последние &amp;lt;tex&amp;gt;r&amp;lt;/tex&amp;gt; бит которого называются '''остатком''' (англ. ''remainder''), а &amp;lt;tex&amp;gt;q = p - r&amp;lt;/tex&amp;gt; старших бит называются '''частным''' (англ. ''quotient''), отсюда название структуры quotient filter&amp;lt;ref&amp;gt;Knuth, Donald (1973). The Art of Computer Programming:Searching and Sorting, volume 3. Section 6.4, exercise 13: Addison Wesley&amp;lt;/ref&amp;gt;. Фильтр представляет собой [[:Хеш-таблица|хеш-таблицу]], в которой харанится остаток и &amp;lt;tex&amp;gt;3&amp;lt;/tex&amp;gt; бита дополнительной информации (удобно хранить в целочисленном типе, используя &amp;lt;tex&amp;gt;3&amp;lt;/tex&amp;gt; старших бита под дополнительную информацию, а оставшиеся биты под остаток, накладывает ограничение на размер остатка). Биты дополнительной информации используются для разрешения ситуации, когда частное различных ключей указывает на одну ячейку в хеш-таблице. Размер хеш-таблицы составляет &amp;lt;tex&amp;gt;2^q&amp;lt;/tex&amp;gt;, так как есть всего &amp;lt;tex&amp;gt;2^q&amp;lt;/tex&amp;gt; разных частных.&lt;br /&gt;
&lt;br /&gt;
Пусть у нас есть ключ &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;, его хеш обозначим &amp;lt;tex&amp;gt;h(K)&amp;lt;/tex&amp;gt;, остаток &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt; и частное &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Попробуем поместить остаток в хеш-таблицу в ячейку с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;, называемую канонической. Возможно, ячейка уже занята, так как существует шанс полных коллизий (остаток и частное разных ключей совпадают) или частичных коллизий (частное разных ключей совпадают). &lt;br /&gt;
При полной коллизии мы получим ложноположительное срабатывание, но при частичной коллизии, с помощью дополнительных битов это избегается. Когда каноническая ячейка занята, помещаем остаток в какую-то ячейку справа. Этот способ решения колизий схож с [[:Разрешение_коллизий|линейным методом разрешения колизий]]. &lt;br /&gt;
&lt;br /&gt;
Последовательность ячеек, имеющих одинаковые частные называется '''пробегом''' (англ. ''run''). Возможно, что начало пробега не занимает канонический слот, если он уже занят каким-то другим пробегом.&lt;br /&gt;
&lt;br /&gt;
Пробег, у которого первый элемент занимает каноническую ячейку, является началом кластера. Кластер {{---}} объединение последовательных пробегов, концом кластера является пустая ячейка или начало другого кластера.&lt;br /&gt;
&lt;br /&gt;
Три дополнительных бита имеют следующие функции:&lt;br /&gt;
* бит занятости {{---}} равен единице, если ячейка является канонической для некого ключа в фильтре, сохраненого необязательно в этой ячейке,&lt;br /&gt;
* бит продолжения {{---}} равен единице, если ячейка занята, но не первым элементов пробеге,&lt;br /&gt;
* бит сдвига {{---}} равен единице, если пробег сдвинут относительно канонического слота.&lt;br /&gt;
&lt;br /&gt;
[[Файл:Quotient Filter.png|500px|thumb|right|Пример последовательной вставки элементов &amp;lt;tex&amp;gt; b, f, e, c, d, a&amp;lt;/tex&amp;gt;]]&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; border=1&lt;br /&gt;
|+&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#EEEEFF &lt;br /&gt;
! Бит занятости || Бит Продолжения || Бит сдвига || Описание &lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||0||0||style=&amp;quot;text-align:left;&amp;quot;|Пустая ячейка.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||0||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит начало пробега, сдвинутого относительно канонического слота.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||1||0||style=&amp;quot;text-align:left;&amp;quot;|Не используется. &lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||1||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит элемент пробега (не первый), сдвинутого относительно канонического слота.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||0||0||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит первый элемет пробега в его каноническом слоте.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||0||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит первый элемет пробега, сдвинутого относительно канонического слота. Ячейка является канонической, для существующего пробега сдвинутого вправо.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||1||0||style=&amp;quot;text-align:left;&amp;quot;|Не используется.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||1||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит элемент пробега (не первый), сдвинутого относительно канонического слота. Ячейка является канонической, для существующего пробега сдвинутого вправо.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
=== Поиск ===&lt;br /&gt;
&lt;br /&gt;
Пусть мы ищем ключ &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;. Смотрим в ячейку с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;, это каноническая ячейка для частного &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Если в этой ячейке бит занятости не единица, то элемент точно не содержится в множестве.&lt;br /&gt;
Если бит занятости единица, то нам нужно найти пробег для &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Так как начало нужного пробега может быть сдвинуто, найдем начало кластера. Идем влево от ячейки с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; и ищем первую с битом сдвига равным нулю, эта ячейка и будет началом кластера. Пока мы идем влево от ячейки с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; будем поддерживать счетчик, который бедет показывать сколько пробегов нам нужно будет пропустить от начала кластера. Каждая ячейка с битом занятости равным единице увеличивает счетчик на &amp;lt;tex&amp;gt;1&amp;lt;/tex&amp;gt;. После того как мы нашли начало кластера, пойдем от него влево, каждая ячейка с битом продолжения равным нулю говорит о завершении пробега, когда счетчик станет равным нулю мы найдем нужный нам пробег для частного &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Если в этом пробеге содержится &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt;, то &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;, вероятно, содержится в множестве, иначе &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt; точно не содержится в множестве.&lt;br /&gt;
&lt;br /&gt;
=== Вставка ===&lt;br /&gt;
&lt;br /&gt;
Аналогично с поиском: найдем позицию для &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt;, сдвигаем на одну позицию влево все эллементы кластера, начиная с выбранного, обновляем дополнительные биты. &lt;br /&gt;
&lt;br /&gt;
* Сдвиг не влияет на бит занятости. Выставляем бит занятости в ячейке &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; в единицу.&lt;br /&gt;
* Если мы вставляем &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt; в начало пробега, следовательно предыдущий элемент пробега стал вторым, у него нужно выставить бит продолжения.&lt;br /&gt;
* Мы выставляем бит сдвига в единицу для каждой ячейки, что мы сдвинули.&lt;br /&gt;
&lt;br /&gt;
== Преимущества ==&lt;br /&gt;
&lt;br /&gt;
* Последовательное расположение данных. Можно загружать только &amp;lt;tex&amp;gt;1&amp;lt;/tex&amp;gt; кластер, уменьшая количество кеш промахов.&lt;br /&gt;
* Простое увеличение или уменьшение хеш-таблицы, достаточно перенести один бит из остатка в частное или наоборот.&lt;br /&gt;
* Простое слияние двух фильтров.&lt;br /&gt;
&lt;br /&gt;
==См. также==&lt;br /&gt;
&lt;br /&gt;
*[[:Идеальное_хеширование|Идеальное хеширование]]&lt;br /&gt;
*[[:Универсальное_семейство_хеш-функций|Универсальное хеширование]]&lt;br /&gt;
&lt;br /&gt;
==Примечания==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации ==&lt;br /&gt;
&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Quotient_filter Wikipedia — Quotient filter]&lt;br /&gt;
* [http://habrahabr.ru/post/242285/  Habrahabr — Quotient filter]&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;br /&gt;
[[Категория: Структуры данных]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=Quotient_filter&amp;diff=50905</id>
		<title>Quotient filter</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=Quotient_filter&amp;diff=50905"/>
				<updated>2016-01-08T14:56:07Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Quotient filter''' {{---}} [[Фильтр_Блума#Вероятностное множество|вероятностная структура данных, позволяющая проверить принадлежность элемента множеству]]. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное (элемент в множестве есть, но структура данных сообщает, что его нет).&lt;br /&gt;
&lt;br /&gt;
Существует связь между размером хранилища и шансом ложноположительного срабатывания. Поддерживаются операции добавления нового элемента в множество. С увеличением размера хранимого множества повышается вероятность ложного срабатывания. &lt;br /&gt;
Структуру разработал Michael Bender в 2011 году&amp;lt;ref&amp;gt;Bender, Michael A.; Farach-Colton, Martin; Johnson, Rob; Kuszmaul, Bradley C.; Medjedovic, Dzejla; Montes, Pablo; Shetty, Pradeep; Spillane, Richard P.; Zadok, Erez (June 2011).[http://vldb.org/pvldb/vol5/p1627_michaelabender_vldb2012.pdf &amp;quot;Don't thrash: how to cache your hash on flash&amp;quot; (PDF)]&amp;lt;/ref&amp;gt; как замена [[:Фильтр_Блума|фильтра Блума]]. Фильтр используется для ускорения ответов в хранилище ключ-значение.  &lt;br /&gt;
&lt;br /&gt;
==Описание структуры данных==&lt;br /&gt;
[[Файл:filter.png|400px|thumb|right|Фильтр используется для ускорения ответов в хранилище ключ-значение. Пары ключ-значение содержатся в хранилище с медленным доступом. Фильтр отфильтровывает ненужные запросы в хранилище (запрос ключа которого точно нет в хранилище), что ускоряет его работу вцелом, но увеличевает потребление памяти]]&lt;br /&gt;
&lt;br /&gt;
В quotient filter хеш-функция возвращает &amp;lt;tex&amp;gt;p&amp;lt;/tex&amp;gt; битовый хеш, последние &amp;lt;tex&amp;gt;r&amp;lt;/tex&amp;gt; бит которого называются '''остатком''' (англ. ''remainder''), а &amp;lt;tex&amp;gt;q = p - r&amp;lt;/tex&amp;gt; старших бит называются '''частным''' (англ. ''quotient''), отсюда название структуры quotient filter&amp;lt;ref&amp;gt;Knuth, Donald (1973). The Art of Computer Programming:Searching and Sorting, volume 3. Section 6.4, exercise 13: Addison Wesley&amp;lt;/ref&amp;gt;. Фильтр представляет собой [[:Хеш-таблица|хеш-таблицу]], в которой харанится остаток и &amp;lt;tex&amp;gt;3&amp;lt;/tex&amp;gt; бита дополнительной информации (удобно хранить в целочисленном типе, используя &amp;lt;tex&amp;gt;3&amp;lt;/tex&amp;gt; старших бита под дополнительную информацию, а оставшиеся биты под остаток, накладывает ограничение на размер остатка). Биты дополнительной информации используются для разрешения ситуации, когда частное различных ключей указывает на одну ячейку в хеш-таблице. Размер хеш-таблицы составляет &amp;lt;tex&amp;gt;2^q&amp;lt;/tex&amp;gt;, так как есть всего &amp;lt;tex&amp;gt;2^q&amp;lt;/tex&amp;gt; разных частных.&lt;br /&gt;
&lt;br /&gt;
Пусть у нас есть ключ &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;, его хеш обозначим &amp;lt;tex&amp;gt;h(K)&amp;lt;/tex&amp;gt;, остаток &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt; и частное &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Попробуем поместить остаток в хеш-таблицу в ячейку с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;, называемую канонической. Возможно, ячейка уже занята, так как существует шанс полных коллизий (остаток и частное разных ключей совпадают) или частичных коллизий (частное разных ключей совпадают). &lt;br /&gt;
При полной коллизии мы получим ложноположительное срабатывание, но при частичной коллизии, с помощью дополнительных битов это избегается. Когда каноническая ячейка занята, помещаем остаток в какую-то ячейку справа. Этот способ решения колизий схож с [[:Разрешение_коллизий|линейным методом разрешения колизий]]. &lt;br /&gt;
&lt;br /&gt;
Последовательность ячеек, имеющих одинаковые частные называется '''пробегом''' (англ. ''run''). Возможно, что начало пробега не занимает канонический слот, если он уже занят каким-то другим пробегом.&lt;br /&gt;
&lt;br /&gt;
Пробег, у которого первый элемент занимает каноническую ячейку, является началом кластера. Кластер {{---}} объединение последовательных пробегов, концом кластера является пустая ячейка или начало другого кластера.&lt;br /&gt;
&lt;br /&gt;
Три дополнительных бита имеют следующие функции:&lt;br /&gt;
* бит занятости {{---}} равен единице, если ячейка является канонической для некого ключа в фильтре, сохраненого необязательно в этой ячейке,&lt;br /&gt;
* бит продолжения {{---}} равен единице, если ячейка занята, но не первым элементов пробеге,&lt;br /&gt;
* бит сдвига {{---}} равен единице, если пробег сдвинут относительно канонического слота.&lt;br /&gt;
&lt;br /&gt;
[[Файл:Quotient Filter.png|500px|thumb|right|Пример последовательной вставки элементов &amp;lt;tex&amp;gt; b, f, e, c, d, a&amp;lt;/tex&amp;gt;]]&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot; border=1&lt;br /&gt;
|+&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#EEEEFF &lt;br /&gt;
! Бит занятости || Бит Продолжения || Бит сдвига || Описание &lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||0||0||style=&amp;quot;text-align:left;&amp;quot;|Пустая ячейка.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||0||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит начало пробега, сдвинутого относительно канонического слота.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||1||0||style=&amp;quot;text-align:left;&amp;quot;|Не используется. &lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|0||1||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит элемент пробега (не первый), сдвинутого относительно канонического слота.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||0||0||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит первый элемет пробега в его каноническом слоте.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||0||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит первый элемет пробега, сдвинутого относительно канонического слота. Ячейка является канонической, для существующего пробега сдвинутого вправо.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||1||0||style=&amp;quot;text-align:left;&amp;quot;|Не используется.&lt;br /&gt;
|-align=&amp;quot;center&amp;quot; bgcolor=#FFFFFF&lt;br /&gt;
|1||1||1||style=&amp;quot;text-align:left;&amp;quot;|Ячейка содержит элемент пробега (не первый), сдвинутого относительно канонического слота. Ячейка является канонической, для существующего пробега сдвинутого вправо.&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
=== Поиск ===&lt;br /&gt;
&lt;br /&gt;
Пусть мы ищем ключ &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;. Смотрим в ячейку с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;, это каноническая ячейка для частного &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Если в этой ячейке бит занятости не единица, то элемент точно не содержится в множестве.&lt;br /&gt;
Если бит занятости единица, то нам нужно найти пробег для &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Так как начало нужного пробега может быть сдвинуто, найдем начало кластера. Идем влево от ячейки с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; и ищем первую с битом сдвига равным нулю, эта ячейка и будет началом кластера. Пока мы идем влево от ячейки с индексом &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; будем поддерживать счетчик, который бедет показывать сколько пробегов нам нужно будет пропустить от начала кластера. Каждая ячейка с битом занятости равным единице увеличивает счетчик на &amp;lt;tex&amp;gt;1&amp;lt;/tex&amp;gt;. После того как мы нашли начало кластера, пойдем от него влево, каждая ячейка с битом продолжения равным нулю говорит о завершении пробега, когда счетчик станет равным нулю мы найдем нужный нам пробег для частного &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt;. Если в этом пробеге содержится &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt;, то &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt;, вероятно, содержится в множестве, иначе &amp;lt;tex&amp;gt;K&amp;lt;/tex&amp;gt; точно не содержится в множестве.&lt;br /&gt;
&lt;br /&gt;
=== Вставка ===&lt;br /&gt;
&lt;br /&gt;
Аналогично с поиском: найдем позицию для &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt;, сдвигаем на одну позицию влево все эллементы кластера, начиная с выбранного, обновляем дополнительные биты. &lt;br /&gt;
&lt;br /&gt;
* Сдвиг не влияет на бит занятости. Выставляем бит занятости в ячейке &amp;lt;tex&amp;gt;h_q&amp;lt;/tex&amp;gt; в единицу.&lt;br /&gt;
* Если мы вставляем &amp;lt;tex&amp;gt;h_r&amp;lt;/tex&amp;gt; в начало пробега, следовательно предыдущий элемент пробега стал вторым, у него нужно выставить бит продолжения.&lt;br /&gt;
* Мы выставляем бит сдвига в единицу для каждой ячейки, что мы сдвинули.&lt;br /&gt;
&lt;br /&gt;
== Преимущества ==&lt;br /&gt;
&lt;br /&gt;
* Последовательное расположение данных. Можно загружать только &amp;lt;tex&amp;gt;1&amp;lt;/tex&amp;gt; кластер, уменьшая количество кеш промахов.&lt;br /&gt;
* Простое увеличение или уменьшение хеш-таблицы, достаточно перенести один бит из остатка в частное или наоборот.&lt;br /&gt;
* Простое слияние двух фильтров.&lt;br /&gt;
&lt;br /&gt;
==См. также==&lt;br /&gt;
&lt;br /&gt;
*[[:Идеальное_хеширование|Идеальное хеширование]]&lt;br /&gt;
*[[:Универсальное_семейство_хеш-функций|Универсальное хеширование]]&lt;br /&gt;
&lt;br /&gt;
==Примечания==&lt;br /&gt;
&lt;br /&gt;
&amp;lt;references /&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Источники информации ==&lt;br /&gt;
&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Quotient_filter Wikipedia — Quotient filter]&lt;br /&gt;
* [http://habrahabr.ru/post/242285/  Habrahabr — Quotient filter]&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;br /&gt;
[[Категория: Структуры данных]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50904</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50904"/>
				<updated>2016-01-08T14:52:33Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Вероятностное множество ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума является примером '''вероятностного множества''', структуры данных, способной добавлять элемент в множество и способной также с некоторой вероятностью корректно отвечать на запрос о наличии элемента в множестве. В ответ на некоторый запрос есть вероятность получить положительный ответ, даже если этого элемента в данном множестве нет. Но если же запрашиваемый элемент в множестве есть, ответ в любом случае будет положительным. Чем больше размер этого множества, тем меньше вероятность получить некорректный ответ на запрос о наличии какого-либо элемента.&lt;br /&gt;
&lt;br /&gt;
Google BigTable использует фильтры Блума, пример '''вероятностного множества''', для уменьшения числа обращений к жесткому диску при проверке на существование заданной строки или столбца в таблице базы данных. Такой подход к нахождению необходимого элемента в базе данных значительно ускоряет сам процесс поиска и уменьшает количество обращений к жесткому диску.&lt;br /&gt;
&lt;br /&gt;
Проще говоря, вероятностное множество - это структура, позволяющая проверить принадлежность элемента множеству. Ответ может быть:&lt;br /&gt;
&lt;br /&gt;
* Элемент точно не принадлежит множеству,&lt;br /&gt;
* Элемент возможно принадлежит множеству.&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50901</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50901"/>
				<updated>2016-01-08T13:14:31Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Описание структуры данных */ добавлено преимущество фильтра Блума. то бишь ответ на вопрос &amp;quot;А зачем нужна такая структура данных?&amp;quot;&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
По сравнению с [[Хеш-таблица|хеш-таблицами]], фильтр Блума может обходиться на несколько порядков меньшими объёмами памяти, жертвуя детерминизмом. Обычно он используется для уменьшения числа запросов к несуществующим данным в структуре данных с более дорогостоящим доступом (например, расположенной на жестком диске или в сетевой базе данных), то есть для «фильтрации» запросов к ней.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50900</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50900"/>
				<updated>2016-01-08T12:58:35Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Свойства */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать &amp;lt;tex&amp;gt; 1 &amp;lt;/tex&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] &amp;lt;tex&amp;gt;  \vee &amp;lt;/tex&amp;gt;  и &amp;lt;tex&amp;gt;\wedge &amp;lt;/tex&amp;gt; .&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50899</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50899"/>
				<updated>2016-01-08T12:52:55Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Минимизация вероятности ложноположительного срабатывания */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;180&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать 1.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] OR и AND.&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50898</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50898"/>
				<updated>2016-01-08T12:47:23Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: engl terms&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' (англ. ''Bloom filter'') — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать 1.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] OR и AND.&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	<entry>
		<id>http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50897</id>
		<title>Фильтр Блума</title>
		<link rel="alternate" type="text/html" href="http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0&amp;diff=50897"/>
				<updated>2016-01-08T12:39:45Z</updated>
		
		<summary type="html">&lt;p&gt;Kuro: /* Источники */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;'''Фильтр Блума''' — это структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложноположительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложноотрицательное.&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может использовать любой объём памяти, заранее заданный пользователем, причем чем он больше, тем меньше вероятность ложного срабатывания. Поддерживается операция добавления новых элементов в множество, но не удаления существующих (если только не используется модификация со счётчиками). С увеличением размера хранимого множества повышается вероятность ложного срабатывания.&lt;br /&gt;
&lt;br /&gt;
== Описание структуры данных ==&lt;br /&gt;
&lt;br /&gt;
[[Файл:bloom_filter.png|400px|thumb|Фильтр Блума с &amp;lt;tex&amp;gt;m = 9&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;k = 3&amp;lt;/tex&amp;gt;, хранящий множество из элементов &amp;lt;tex&amp;gt;A&amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt;B&amp;lt;/tex&amp;gt;. Этот фильтр Блума может определить, что элемент &amp;lt;tex&amp;gt;C&amp;lt;/tex&amp;gt; входит в множество, хотя он и не добавлен в него.]]&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума представляет собой битовый массив из &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит и &amp;lt;tex&amp;gt;k&amp;lt;/tex&amp;gt; различных [[Хеширование|хеш-функций]] &amp;lt;tex&amp;gt;h_1 \dots h_k&amp;lt;/tex&amp;gt;, равновероятно отображающих элементы исходного множества во множество &amp;lt;tex&amp;gt; \big\{ 0, 1, \dots m - 1 \big\}&amp;lt;/tex&amp;gt;, соответствующее номерам битов в массиве. &lt;br /&gt;
Изначально, когда структура данных хранит пустое множество, все &amp;lt;tex&amp;gt;m&amp;lt;/tex&amp;gt; бит обнулены.&lt;br /&gt;
&lt;br /&gt;
Для добавления элемента &amp;lt;tex&amp;gt; e &amp;lt;/tex&amp;gt; необходимо записать единицы на каждую из позиций &amp;lt;tex&amp;gt;h_1(e) \dots h_k(e)&amp;lt;/tex&amp;gt; битового массива.&lt;br /&gt;
&lt;br /&gt;
Чтобы проверить, что элемент &amp;lt;tex&amp;gt;e&amp;lt;/tex&amp;gt; принадлежит множеству хранимых элементов, необходимо проверить состояние битов &amp;lt;tex&amp;gt; h_1(e) \dots h_k(e) &amp;lt;/tex&amp;gt;. Если хотя бы один из них равен нулю, элемент не принадлежит множеству. Если все они равны единице, то структура данных сообщает, что элемент принадлежит множеству. При этом может возникнуть две ситуации: либо элемент действительно принадлежит к множеству, либо все эти биты оказались установлены при добавлении других элементов, что и является источником ложных срабатываний в этой структуре данных.&lt;br /&gt;
&lt;br /&gt;
== Минимизация вероятности ложноположительного срабатывания ==&lt;br /&gt;
&lt;br /&gt;
Пусть размер битового массива &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt;, и заданы &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; хеш-функций, причем все хеш-функции выбираются случайным образом. Тогда вероятность, что в &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит не будет записана единица &amp;lt;tex&amp;gt; i &amp;lt;/tex&amp;gt;-ой хеш-функцией при вставке очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j) = 1 - \frac {1}{m} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Так как для упрощения анализа мы предполагаем, что значения хеш-функций являются [[Независимые случайные величины#Независимость в совокупности|независимыми в совокупности]] [[Дискретная случайная величина|случайными величинами]], то вероятность, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит останется нулевым после добавления очередного элемента, равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;p(h_i(x) \neq j&amp;lt;/tex&amp;gt; для &amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt; \forall i \in \big\{ 1 \dots k \big\}) = (1 - \frac {1}{m})^k &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
А вероятность того, что &amp;lt;tex&amp;gt; j &amp;lt;/tex&amp;gt;-ый бит будет равен нулю после вставки &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt; различных элементов в изначально пустой фильтр:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} &amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
В силу второго замечательного предела и достаточно большого &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; можем это записать как:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - \frac {1}{m})^{kn} \approx e^{-kn/m}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Ложноположительное срабатывание происходит тогда, когда для несуществующего элемента все &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt; бит окажутся ненулевыми, и фильтр Блума ответит, что он входит в число вставленных элементов.&lt;br /&gt;
Тогда вероятность такого события равна:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;(1 - e^{-kn/m})^k&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Для фиксированных &amp;lt;tex&amp;gt; m &amp;lt;/tex&amp;gt; и &amp;lt;tex&amp;gt; n &amp;lt;/tex&amp;gt;, оптимальное число хеш-функций &amp;lt;tex&amp;gt; k &amp;lt;/tex&amp;gt;, минимизирующих вероятность ложноположительного срабатывания, равно:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;tex dpi = &amp;quot;150&amp;quot;&amp;gt;k = \ln 2 \frac {m}{n} \approx 0.6931 \frac {m}{n}&amp;lt;/tex&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Свойства ==&lt;br /&gt;
&lt;br /&gt;
Фильтр Блума может хранить универсальное множество всех возможных элементов. При этом все ячейки битового массива будут содержать 1.&lt;br /&gt;
&lt;br /&gt;
При существование двух фильтров Блума одинаковых размеров и с одинаковыми наборами хеш-функций, их объединение и пересечение может быть реализовано с помощью [[Определение_булевой_функции#Бинарные функции|побитовых операций]] OR и AND.&lt;br /&gt;
&lt;br /&gt;
== Источники информации==&lt;br /&gt;
* [http://ru.wikipedia.org/wiki/Фильтр_Блума Википедия {{---}} Фильтр Блума]&lt;br /&gt;
* [http://en.wikipedia.org/wiki/Bloom_filter Wikipedia {{---}} Bloom filter]&lt;br /&gt;
*Demetrescu, Camil. «Experimental Algorithms» {{---}} «Springer», 2007 г. {{---}} 108-121 стр. {{---}} ISBN 978-3-540-72844-3&lt;br /&gt;
&lt;br /&gt;
[[Категория: Дискретная математика и алгоритмы ]]&lt;br /&gt;
[[Категория: Хеширование]]&lt;/div&gt;</summary>
		<author><name>Kuro</name></author>	</entry>

	</feed>