N-Hash [SEP] based on
[{"answer": "FEAL", "provenance": [{"wikipedia_id": "1002247", "title": "N-Hash", "start_paragraph_id": 1, "start_character": 0, "end_paragraph_id": 1, "end_character": 122, "bleu_score": 1.0, "meta": {}, "section": "Section::::Abstract."}]}]
N-Hash


In cryptography, N-Hash is a cryptographic hash function based on the FEAL round function, and is now considered insecure. It was proposed in 1990 by Miyaguchi et al.; weaknesses were published the following year. N-Hash has a 128-bit hash size. A message is divided into 128-bit blocks, and each block is combined with the hash value computed so far using the "g" compression function. "g" contains eight rounds, each of which uses an "F" function, similar to the one
14349607
Hash function


. A hash function that will relocate the minimum number of records when the table is – where "z" is the key being hashed and "n" is the number of allowed hash values – such that "H"("z","n" + 1) = "H"("z","n") with probability close to "n"/("n" + 1). Linear hashing and spiral storage are examples of dynamic hash functions that execute in constant time but relax the property of uniformity to achieve the minimal movement property. Extendible hashing uses a dynamic hash function that requires
13702562
Rendezvous hashing


once a hash function "h()" is chosen (the original work on the HRW method makes a hash function recommendation). Each client only needs to compute a hash value for each of the "n" sites, and then pick the largest. This algorithm runs in "O(n)" time. If the hash function is efficient, the "O(n)" running time is not a problem, unless "n" is very large. In the standard implementation of rendezvous hashing, every node receives a statically
1215084
Hash function


proportional to "k"·"n". However, with the proper choice of "h", one can use the technique of rolling hash to compute all those hashes with an effort proportional to "k" + "n". A universal hashing scheme is a randomized algorithm that selects a hashing function "h" among a family of such functions, in such a way that the probability of a collision of any two distinct keys is 1/"n", where "n" is the number of distinct hash values desired—independently of
13702579
Four fours


-a, a*b, a/b, b/a)" into the hash table, including parenthesis, for "n=4". Here the sets "A" and "B" that contain "a" and "b" are calculated recursively, with "n=1" and "n=2" being the base case. Memoization is used to ensure that every hash table is only computed once. The second case (factorials and roots) is treated with the help of an auxiliary function, which is invoked every time
7838044
Hash function


locate the desired entry in a hash table, without any additional searching. A perfect hash function for "n" keys is said to be minimal if its range consists of "n" "consecutive" integers, usually from 0 to "n"−1. Besides providing single-step lookup, a minimal perfect hash function also yields a compact hash table, without any vacant slots. Minimal perfect hash functions are much harder to find than perfect ones with a wider range. If the inputs are bounded-length strings and each input
13702570
Hash function


and the number "n" of allowed hash values. A common solution is to compute a fixed hash function with a very large range (say, 0 to 2 − 1), divide the result by "n", and use the division's remainder. If "n" is itself a power of 2, this can be done by bit masking and bit shifting. When this approach is used, the hash function must be chosen so that the result has fairly uniform distribution between 0 and "n" −
13702559
Static hashing


personnel, etc. Perfect hashing is a model of hashing in which any set of n elements can be stored in a hash table of equal size and can have lookups done in constant time. It was specifically discovered and discussed by Fredman, Komlos and Szemeredi (1984) and has therefore been nicknamed "FKS Hashing". FKS Hashing makes use of a hash table with two levels in which the top level contains n buckets which each contain their own hash table. FKS hashing requires that if collisions occur they must do so
21039185
Hash function


may independently occur with uniform probability (such as telephone numbers, car license plates, invoice numbers, etc.), then a hash function needs to map roughly the same number of inputs to each hash value. For instance, suppose that each input is an integer "z" in the range 0 to "N"−1, and the output must be an integer "h" in the range 0 to "n"−1, where "N" is much larger than "n". Then the hash function could be "h
13702571
Lempel–Ziv–Markov chain algorithm


", a hash table indexed by tuples of "k" bytes, where each of the buckets contains the last position where the first "k" bytes hashed to the hash value associated with that hash table bucket. Chaining is achieved by an additional array which stores, for every dictionary position, the last seen previous position whose first "N" bytes hash to the same value of the first "N" bytes of the position in question. To find matches of length "N" or higher, a search is
4223856
Hash function


) that is uniform on the interval [0, 2 − 1]. A hash function uniform on the interval [0, n-1] is "n" "P"(key)/2. We can replace the division by a (possibly faster) right bit shift: "nP"(key) » "b". When the hash function is used to store values in a hash table that outlives the run of the program, and the hash table needs to be expanded or shrunk, the hash table is referred to as a dynamic hash table
13702561
Rendezvous hashing


virtual nodes at that tier, and once again descend the hierarchy to the real nodes, as above. The value of "m" can be chosen based upon such factors as the anticipated failure rate and the degree of load balancing desired. A higher value of "m" leads to less load skew in the event of failure, at the cost of somewhat higher search overhead. The choice "m = n" is equivalent to non-hierarchical rendezvous hashing. In practice, the hash "h()" is
1215097
Rendezvous hashing


, however, are even more complex than basic consistent hashing. In contrast, rendezvous hashing (HRW) is much simpler both conceptually and in practice. It also distributes objects uniformly over all sites, given a uniform hash function. Unlike consistent hashing, HRW requires no precomputing or storage of tokens. An object "O" is placed into one of "n" sites "S, ..., S" by computing the "n" hash values "h(O,S)" and picking the site "S" that
1215079
Hash function


space proportional to "n" to compute the hash function, and it becomes a function of the previous keys that have been inserted. Several algorithms that preserve the uniformity property but require time proportional to "n" to compute the value of "H"("z","n") have been invented. A hash function with minimal movement is especially useful in distributed hash tables. In some applications, the input data may contain features that are irrelevant for comparison purposes. For example, when looking up a personal name, it may be desirable to
13702563
Distributed hash table


of time) to associate a key to one of the "n" available servers. Each client has the same list of identifiers , one for each server. Given some key "k", a client computes "n" hash weights . The client associates that key with the server corresponding to the highest hash weight for that key. A server with ID formula_19 owns all the keys formula_6 for which the hash weight formula_21 is higher than the hash weight of any other node for that key. Locality-preserving hashing ensures
18008131
Lempel–Ziv–Markov chain algorithm


started using the "N"-sized hash table, and continued using the hash chain array; the search stop after a pre-defined number of hash chain nodes has been traversed, or when the hash chains "wraps around", indicating that the portion of the input that has been overwritten in the dictionary has been reached. Matches of size less than "N" are instead found by simply looking at the corresponding hash table, which either contains the latest such match, if any, or a string that hashes to the same
4223857
Hash function


input strings are broken into many small pieces, and a hash function is used to detect potentially equal pieces, as above. The Rabin–Karp algorithm is a relatively fast string searching algorithm that works in O("n") time on average. It is based on the use of hashing to compare strings. This principle is widely used in computer graphics, computational geometry and many other disciplines, to solve many proximity problems in the plane or in three-dimensional space, such as finding closest pairs in a set of points,
13702547
Rainbow table


Θ(|P|"n") bits of space, where "n" is the size of an output of H, which is prohibitive for large |P|. Hash chains are a technique for decreasing this space requirement. The idea is to define a "reduction function" R that maps hash values back into values in P. Note, however, that the reduction function is not actually an inverse of the hash function, but rather a different function with a swapped domain and codomain of the hash function. By alternating the hash function with the reduction
13514093
Hash array mapped trie


pointer or a pointer to another node. N is commonly 32. As allocating space for N pointers for each node would be expensive, each node instead contains a bitmap which is N bits long where each bit indicates the presence of a non-nil pointer. This is followed by an array of pointers equal in length to the number of ones in the bitmap, (its Hamming weight). The hash array mapped trie achieves almost hash table-like speed while using memory much more economically. Also, a hash table
14983048
Koorde


In peer-to-peer networks, Koorde is a Distributed hash table (DHT) system based on the Chord DHT and the De Bruijn graph (De Bruijn sequence). Inheriting the simplicity of Chord, Koorde meets O(log n) hops per node (where n is the number of nodes in the DHT), and O(log n/ log log n) hops per lookup request with O(log n) neighbors per node. The Chord concept is based on a wide range of identifiers (e.g. 2^160) in a structure
3743772
2-choice hashing


2-choice hashing, also known as 2-choice chaining, is "a variant of a hash table in which keys are added by hashing with two hash functions. The key is put in the array position with the fewer (colliding) keys. Some collision resolution scheme is needed, unless keys are kept in buckets. The average-case cost of a successful search is O(2 + (m-1)/n), where m is the number of keys and n is the size of the array. The most collisions is formula_1 with high probability.
12791927
Hash table


list of the single most recent key value at each hash table resize operation. Upon lookup, keys that fall in the ranges defined by these list entries are directed to the appropriate hash function—and indeed hash table—both of which can be different for each range. Since it is common to grow the overall number of entries by doubling, there will only be O(log("N")) ranges to check, and binary search time for the redirection would be O(log(log("N"))). As with consistent hashing, this approach
13843745
Lamport signature


that generates an n-bit message digest, the ideal preimage and 2nd preimage resistance on a single hash function invocation implies on the order of 2 operations to find a collision under a classical computing model. According to Grover's algorithm, finding a preimage collision on a single invocation of an ideal hash function is upper bound on O(2) operations under a quantum computing model. In Lamport signatures, each bit of the public key and signature is based on short messages requiring only a single invocation to a hash function. For each
6341567
Cryptographic hash function


but not more collision-resistant. Antoine Joux observed that 2-collisions lead to "n"-collisions: if it is feasible for an attacker to find two messages with the same MD5 hash, the attacker can find as many messages as the attacker desires with identical MD5 hashes with no greater difficulty. Among the n messages with the same MD5 hash, there is likely to be a collision in SHA-1. The additional work needed to find the SHA-1 collision (beyond the exponential birthday search) requires only polynomial time. There are many cryptographic hash
4875734
Dynamic array


for order preserving insertions or deletions from the middle of the array. Hashed array tree (HAT) is a dynamic array algorithm published by Sitarski in 1996. Hashed array tree wastes order n amount of storage space, where n is the number of elements in the array. The algorithm has O(1) amortized performance when appending a series of objects to the end of a hashed array tree. In a 1999 paper, Brodnik et al. describe a tiered dynamic array data structure, which wastes only n space for "n"
5835802
Hash function


slots, the probability of a bucket receiving many more than "m"/"n" records should be vanishingly small. In particular, if "m" is less than "n", very few buckets should have more than one or two records. (In an ideal "perfect hash function", no bucket should have more than one record; but a small number of collisions is virtually inevitable, even if "n" is much larger than "m" – see the birthday problem). When testing a hash function,
13702555
BitVault


table into smaller hash tables. For example, if there are n peers, the hash table would be divided into n hash tables, each starting from the row next to where its immediate predecessor ended. Each DHT has its associated brick, and the extent of the logical address space a brick is responsible for is called its Zone. The bricks communicate using peer-to-peer technology, over the Membership and Routing Layer (MRL). Lookup of any data object can be done by n bricks in parallel, in
22156454
Hash function


real-world distribution—no matter how non-uniform and dependent—to a 32-bit or 64-bit string, from which one can extract a hash value in 0 through "n" − 1. This method may produce a sufficiently uniform distribution of hash values, as long as the hash range size "n" is small compared to the range of the checksum or fingerprint function. However, some checksums fare poorly in the avalanche test, which may be a concern in some applications. In particular, the popular CRC32 checksum
13702581
Hash table


a self-balancing binary search tree, the theoretical worst-case time of common hash table operations (insertion, deletion, lookup) can be brought down to O(log "n") rather than O("n"). However, this introduces extra complexity into the implementation, and may cause even worse performance for smaller hash tables, where the time spent inserting into and balancing the tree is greater than the time needed to perform a linear search on all of the elements of a list. A real world example of a hash
13843720
Fowler–Noll–Vo hash function


FNV prime is a prime number and is determined as follows: For a given formula_1: where formula_4 is: and where formula_6 is: then the "n"-bit FNV prime is the smallest prime number formula_9 that is of the form: such that: Experimentally, FNV prime matching the above constraints tend to have better dispersion properties. They improve the polynomial feedback characteristic when an FNV prime multiplies an intermediate hash value. As such, the hash values produced are more scattered throughout the "n"-bit hash space. The above FNV prime constraints
5708512
One-way compression function


rate of an iterated hash function outlines the ratio between the number of block cipher operations and the output. More precisely, if n denotes the output bit-length of the block cipher the rate represents the ratio between the number of processed bits of input m, n output bits and the necessary block cipher operations s to produce these n output bits. Generally, the usage of fewer block cipher operations could result in a better overall performance of the entire hash function but it also leads to a smaller hash-value which could
2475687
Dynamic perfect hashing


O("n") space, and more specifically T  s + 4*x. Fredman, Komlós and Szemerédi showed that given a universal hashing family of hash functions, at least half of those functions have that property. Dietzfelbinger et al. present a dynamic dictionary algorithm that, when a set of n items is incrementally added to the dictionary, membership queries always run in constant time and therefore O(1) worst-case time, the total storage required is O(n) (linear), and O(1) expected amortized insertion and deletion time (
8836403
Jemmis mno rules


to form a macropolyhedron, m core BMOs will be formed. Thus the SEP requirement of closo-condensed polyhedral clusters is m+n. Single-vertex sharing is a special case, where each sub-cluster needs to satisfy Wade’s rule separately. Let a and b be the number of vertices in the sub-clusters including the shared atom. The first cage requires a+1 and second cage requires b+1 skeletal electron pairs (SEPs). Thus a total of a+b+2 or a+b+m SEPs are required; but a+b = n+1, as
17447251
Jemmis mno rules


species. Closo-BH is formed by the face-sharing condensation of two icosahedra. The m+n+o+p-q rule demands 23 SEPs; 18 BH units provide 18 pairs, 3 shared boron atoms provide 4.5 pairs; the negative charge provide 0.5 pair. Thus a total of 23 SEPs are available, which is the same as the required count. The bis-nido-BH is formed by the edge-sharing condensation of nido-B unit and nido-B unit. The m+n+o+p-q count of 16 SEPs are
17447254
SUHA (computer science)


the probability that two non-equal elements will hash to the same slot is Under the assumption of uniform hashing, the load factor formula_2 and the average chain length of a hash table of size m with n elements will be Under the assumption of uniform hashing, the average time (in big-O notation) to successfully find an element in a hash table using chaining is Under the assumption of uniform hashing, the average time (in big-O notation) to unsuccessfully find an element in a hash table using chaining
20360246
Coalesced hashing


the effect of coalescing, is to restrict the address space of the hash function to only a subset of the table. For example, if the table has size "M" with buckets numbered from 0 to "M − 1", we can restrict the address space so that the hash function only assigns addresses to the first "N" locations in the table. The remaining "M − N" buckets, called the "cellar", are used exclusively for storing items that collide during insertion. No coalescing can
11324305
Merkle–Damgård construction


length. If a hash of "n" bits is desired, the compression function "f" takes "2n" bits of chaining value and "m" bits of the message and compresses this to an output of "2n" bits. Therefore, in a final step a second compression function compresses the last internal hash value ("2n" bit) to the final hash value ("n" bit). This can be done as simply as discarding half of the last "2n"-bit-output. SHA-512/224 and
13202658
Rolling hash


create dynamic, content-based chunks of a stream or file. This is especially useful when it is required to send only the changed chunks of a large file over a network and a simple byte addition at the front of the file would cause all the fixed size windows to become updated, while in reality, only the first "chunk" has been modified. The simplest approach to calculate the dynamic chunks is to calculate the rolling hash and if it matches a pattern (like the lower "N" bits are all
12994567
Static hashing


only on the top level. The top level contains a randomly created hash function, h(x), which fits within the constraints of a Carter and Wegman hash function - seen in Universal hashing. Having done so the top level shall contain n buckets labeled k, k, k, ..., k. Following this pattern, all of the buckets hold a hash table of size s and a respective hash function, h(x). The hash function will be decided by setting s to k and randomly going through functions until there are
21039186
Rendezvous hashing


Rendezvous or highest random weight (HRW) hashing is an algorithm that allows clients to achieve distributed agreement on a set of "k" options out of a possible set of "n" options. A typical application is when clients need to agree on which sites (or proxies) objects are assigned to. As shown below, Rendezvous hashing is more general than Consistent hashing, which becomes a special case (for "k" = 1) of Rendezvous hashing. Rendezvous hashing was invented by David Thaler and Chinya Ravishankar at
1215069
Rendezvous hashing


other sites. It might first appear sufficient to treat the "n" sites as buckets in a hash table and hash the object name "O" into this table. However, if any of the sites fails or is unreachable, the hash table size changes, requiring all objects to be remapped. This massive disruption makes such direct hashing unworkable. Under rendezvous hashing, however, clients handle site failures by picking the site that yields the next largest weight. Remapping is required only for objects currently mapped to the failed site
1215075
Hopscotch hashing


Hopscotch hashing is a scheme in computer programming for resolving hash collisions of values of hash functions in a table using open addressing. It is also well suited for implementing a concurrent hash table. Hopscotch hashing was introduced by Maurice Herlihy, Nir Shavit and Moran Tzafrir in 2008. The name is derived from the sequence of hops that characterize the table's insertion algorithm. The algorithm uses a single array of "n" buckets. For each bucket, its "neighborhood" is a small collection of nearby consecutive buckets (i.e. ones
6421228
Delone set


of cells of diameter ε, and using a hash table to test which nearby cells already contain points of "N"; thus, in this case, an ε-net can be constructed in linear time. For more general finite or compact metric spaces, an alternative algorithm of Teo Gonzalez based on the farthest-first traversal can be used to construct a finite ε-net. This algorithm initializes the net "N" to be empty, and then repeatedly adds to "N" the farthest point in "M
8288767
RC4


a modified algorithm is traditionally called "RC4-drop[n]", where n is the number of initial keystream bytes that are dropped. The SCAN default is n = 768 bytes, but a conservative value would be n = 3072 bytes. The Fluhrer, Mantin and Shamir attack does not apply to RC4-based SSL, since SSL generates the encryption keys it uses for RC4 by hashing, meaning that different SSL sessions have unrelated keys. In 2005, Andreas Klein presented an analysis of the RC4 stream cipher showing more correlations between the RC4 keystream
6274298
Selection algorithm


O(sqrt("n")) time. Unfortunately, this strategy is also sensitive to clustering of elements in a narrow interval, which may result in buckets with large numbers of elements (clustering can be eliminated through a good hash function, but finding the element with the "k"th largest hash value isn't very useful). Additionally, like hash tables this structure requires table resizings to maintain efficiency as elements are added and "n" becomes much larger than "h". A useful case of this is finding an order statistic or
8847396
Jemmis mno rules


satisfied by ten BH units which provide 10 pairs, two shared boron atoms which provide 3 pairs and six bridging H atoms which provide 3 pairs. m+n+o+p-q = 26 SEPs. A transition metal with n valence electrons will provide n-6 electrons for skeletal bonding, as 6 electrons occupying the metal-like orbitals don’t contribute much to the cluster bonding. Thus Cu provides 2.5 pairs, 22 BH units provide 22 pairs; three negative charges provide 1.5 pair. Thus 26 SEPs are available as required. According to m+n+o+p-
17447255
2018 Nigeria Federation Cup


Katsina United Plateau United 1-1 Enyimba Round 1 [Sep 28] (moved from Sep 24) Plateau United 0-1 Katsina United J. Atete 0-5 Enyimba Final Table: Round 1 [Sep 24] Enugu Rangers 2-1 El-Kanemi Warriors Sunshine Stars 1-1 Supreme Court Round 2 [Sep 26] Sunshine Stars 1-1 El-Kanemi Warriors Supreme Court n/p Enugu Rangers Round 3 [Sep 28] Enugu Rangers 0-0 Sunshine Stars El-Kaneni Warriors 1-0
8216895
Hash table


cases. This is in contrast to most chaining and open addressing methods, where the time for lookup is low on average, but may be very large, O("n"), for instance when all the keys hash to a few values. A critical statistic for a hash table is the "load factor", defined as where As the load factor grows larger, the hash table becomes slower, and it may even fail to work (depending on the method used). The expected constant time property of a hash table
13843709
Rabin–Karp algorithm


require O("m") time. However, line 2 is only executed once, and line 6 is only executed if the hash values match, which is unlikely to happen more than a few times. Line 5 is executed O("n") times, but each comparison only requires constant time, so its impact is O("n"). The issue is line 4. Naively computing the hash value for the substring codice_2 requires O("m") time because each character is examined. Since the hash computation is done on each loop, the
11545257
Hashed array tree


In computer science, a hashed array tree (HAT) is a dynamic array data-structure published by Edward Sitarski in 1996, maintaining an array of separate memory fragments (or "leaves") to store the data elements, unlike simple dynamic arrays which maintain their data in one contiguous memory area. Its primary objective is to reduce the amount of element copying due to automatic array resizing operations, and to improve memory usage patterns. Whereas simple dynamic arrays based on geometric expansion waste linear (Ω("n")) space,
16151267
Numero sign


In online usage, the hash may cause complications because of its usage for hashtags and HTML anchors, a complication not present with the numero sign (thus the numero sign can be used in places the hash cannot). The numero symbol is not in common use in France and does not appear on a standard AZERTY keyboard. Instead, the French Imprimerie nationale recommends the use of the form "n" (an "n" followed by a superscript lowercase "o"). The plural form "n" can
11095972
Four fours


is one table for each number "n" of occurrences of "d". For example, when "d=4", the hash table for two occurrences of "d" would contain the key-value pair "8" and 4+4, and the one for three occurrences, the key-value pair "2" and (4+4)/4 (strings shown in bold). The task is then reduced to recursively computing these hash tables for increasing "n", starting from "n=1" and continuing
7838041
One-way compression function


block-length one-way compression function consists of a block cipher plus a permutation p. It was proposed by Shoichi Hirose in 2006 and is based on a work by Mridul Nandi. It uses a block cipher whose key length "k" is larger than the block length "n", and produces a hash of size 2"n". For example, any of the AES candidates with a 192- or 256-bit key (and 128-bit block). Each round accepts a portion of the message "m" that is "k"−"n
2475701
Hash array mapped trie


A hash array mapped trie (HAMT) is an implementation of an associative array that combines the characteristics of a hash table and an array mapped trie. It is a refined version of the more general notion of a hash tree. A HAMT is an array mapped trie where the keys are first hashed to ensure an even distribution of keys and a constant key length. In a typical implementation of HAMT's array mapped trie, each node contains a table with some fixed number N of slots with each slot containing either a nil
14983047
X-fast trie


Each leaf stores a pointer to its predecessor and successor, thereby forming a doubly linked list. Finally, there is a hash table for each level that contains all the nodes on that level. Together, these hash tables form the level-search structure (LSS). To guarantee the worst-case query times, these hash tables should use dynamic perfect hashing or cuckoo hashing. The total space usage is "O"("n" log "M"), since each element has a root-to-leaf path of length
2885810
Hash table


a bucket that contains "k" entries is organized as a perfect hash table with "k" slots. While it uses more memory ("n" slots for "n" entries, in the worst case and "n" × "k" slots in the average case), this variant has guaranteed constant worst-case lookup time, and low amortized time for insertion. It is also possible to use a fusion tree for each bucket, achieving constant time for all operations with high probability. In another strategy
13843723
Hash calendar


is it possible to use a hash calendar as the basis of a hash-linking based digital timestamping scheme. The hash calendar construct was invented by Estonian cryptographers Ahto Buldas and Mart Saarepera based on their research on the security properties of cryptographic hash functions and hash-linking based digital timestamping. Their design goal was to remove the need for a trusted third party i.e. that the time of the timestamp should be verifiable independently from the issuer of the timestamp. There are different algorithms that can be used to build a hash calendar and
18728394
Rendezvous hashing


to storage nodes in Cleversafe's data storage system, now IBM Cloud Object Storage. Python code implementing a weighted rendezvous hash: Example outputs of wrh: When "n" is extremely large, the following variant can improve running time. This approach creates a virtual hierarchical structure (called a "skeleton"), and achieves "O(log n)" running time by applying HRW at each level while descending the hierarchy. The idea is to first choose some constant "m" and organize the "n" sites into "
1215090
Pathological (mathematics)


pathological" has a slightly different sense with regard to the study of algorithms. Here, an input (or set of inputs) is said to be "pathological" if it causes atypical behavior from the algorithm, such as a violation of its average case complexity, or even its correctness. For example, hash tables generally have pathological inputs: sets of keys that collide on hash values. Quicksort normally has O(n log n) time complexity, but deteriorates to O(n) when given input that triggers suboptimal behaviour. The term
8058876
Digital signature


padded hash function output that corresponds to σ, but not a message that leads to that value, which does not lead to an attack. In the random oracle model, hash-then-sign (an idealized version of that practice where hash and padding combined have close to "N" possible outputs), this form of signature is existentially unforgeable, even against a chosen-plaintext attack. There are several reasons to sign such a hash (or message digest) instead of the whole document. In their foundational paper
14507867
Hash-based cryptography


used to sign messages, while all other trees sign root values of lower trees. The Naor-Yung work shows the pattern by which to transfer a limited time signature of the Merkle type family into an unlimited (regular) signature scheme. Hash-based signature schemes rely on security assumptions about the underlying hash function, but any hash function fulfilling these assumptions can be used. As a consequence, each adequate hash function yields a different corresponding hash-based signature scheme. Even if a given hash function becomes insecure, it
4640424
Feature hashing


vector of a pre-defined length by applying a hash function to the features (e.g., words), then using the hash values directly as feature indices and updating the resulting vector at those indices. Here, we assume that feature actually means feature vector. Thus, if our feature vector is ["cat","dog","cat"] and hash function is formula_2 if formula_3 is "cat" and formula_4 if formula_3 is "dog". Let us take the output feature vector dimension (N) to be 4. Then output x
4912395
Hash-based cryptography


Hash-based cryptography is the generic term for constructions of cryptographic primitives based on the security of hash functions. It is of interest as a type of post-quantum cryptography. So far, hash-based cryptography is limited to digital signatures schemes such as the Merkle signature scheme. Hash-based signature schemes combine a one-time signature scheme with a Merkle tree structure. Since a one-time signature scheme key can only sign a single message securely, it is practical to combine many such keys within a single,
4640416
Self-balancing binary search tree


One advantage of self-balancing BSTs is that they allow fast (indeed, asymptotically optimal) enumeration of the items "in key order", which hash tables do not provide. One disadvantage is that their lookup algorithms get more complicated when there may be multiple items with the same key. Self-balancing BSTs have better worst-case lookup performance than hash tables (O(log n) compared to O(n)), but have worse average-case performance (O(log n) compared to O(1)). Self-balancing
9585630
Hashed array tree


where "n" is the number of elements in the array, hashed array trees waste only order "O"() storage space. An optimization of the algorithm allows elimination of data copying completely, at a cost of increasing the wasted space. It can perform access in constant (O(1)) time, though slightly slower than simple dynamic arrays. The algorithm has O(1) amortized performance when appending a series of objects to the end of a hashed array tree. Contrary to its name, it does not use hash
16151268
Persistent data structure


binary representation of that integer to index into a sparse array at each level of the tree. The leaf nodes of the tree behave similar to the buckets used to construct hash tables and may or may not contain multiple candidates depending on hash collisions. Most implementations of persistent hash array mapped tries use a branching factor of 32 in their implementation. This means that in practice while insertions, deletions, and lookups into a persistent hash array mapped trie have a computational complexity of "O"(log "n"), for most applications they
8027325
Collision attack


either message, but they are arbitrarily chosen by the algorithm. Much like symmetric-key ciphers are vulnerable to brute force attacks, every cryptographic hash function is inherently vulnerable to collisions using a birthday attack. Due to the birthday problem, these attacks are much faster than a brute force would be. A hash of "n" bits can be broken in 2 time (evaluations of the hash function). More efficient attacks are possible by employing cryptanalysis to specific hash functions. When a collision attack is discovered and is found
8705101
Hash-based cryptography


is sufficient to replace it by a different, secure one to obtain a secure instantiation of the hash-based signature scheme under consideration. Some hash-based signature schemes (such as XMSS with pseudorandom key generation) are forward secure, meaning that previous signatures remain valid if a secret key is compromised. The minimality of security assumptions is another characteristic of hash-based signature schemes. Generally, these schemes only require a secure (for instance in the sense of second preimage resistance) cryptographic hash function to guarantee the overall security
4640425
Dynamic perfect hashing


infrequent and independent of the size of "k", providing linear amortized construction time. Although each second-level table requires quadratic space, if the keys inserted into the first-level hash table are uniformly distributed, the structure as a whole occupies expected O("n") space, since bucket sizes are small with high probability. The first-level hash function is specifically chosen so that, for the specific set of x unique key values, the total space T used by all the second-level hash tables has expected
8836402
Set intersection oracle


the elements of "S" into a temporary hash table and then checking for each element of "S" whether it is in the hash table. The query time is formula_1. Alternatively, we can pre-process the sets and create an "n"-by-"n" table where the intersection information is already entered. Then the query time is formula_2, but the memory required is formula_3. Define a "large set" as a set with at least formula_4 elements. Obviously there are at most formula_4 such sets. Create a table
3685900
Noise-based logic


a powerful computing application where the methods is inherently based on calculating the hash function. The scheme is based on random telegraph waves and it is mentioned in the paper that the authors intuitively conclude that the "intelligence" of the brain is using similar operations to make a reasonably good decision based on a limited amount of information. The superposition of the first integer numbers can be produced with only 2"N" operations, which the authors call "Achilles ankle operation" in the paper. Preliminary schemes have already been published to utilize noise
9793363
Very smooth hash


In cryptography, Very Smooth Hash (VSH) is a secure cryptographic hash function invented in 2005 by Scott Contini, Arjen Lenstra and Ron Steinfeld. Provably secure means that finding collisions is as difficult as some known hard mathematical problem. Unlike other secure collision-resistant hashes, VSH is efficient and usable in practice. Asymptotically, it only requires a single multiplication per log("n") message-bits and uses RSA-type arithmetic. Therefore, VSH can be useful in embedded environments where code space is limited. Two major variants
2384237
Hash function


for a specific kind of data may have dismal performance on data with different distribution. In some applications, such as substring search, one must compute a hash function "h" for every "k"-character substring of a given "n"-character string "t"; where "k" is a fixed integer, and "n" is greater than "k". The straightforward solution, which is to extract every such substring "s" of "t" and compute "h"("s") separately, requires a number of operations
13702578
Preimage attack


but does not guarantee preimage resistance. Conversely, a second-preimage attack implies a collision attack (trivially, since, in addition to "x"′, "x" is already known right from the start). By definition, an ideal hash function is such that the fastest way to compute a first or second preimage is through a brute-force attack. For an "n"-bit hash, this attack has a time complexity 2, which is considered too high for a typical output size of "n" = 128 bits
8704702
Cuckoo filter


filters can achieve lower space overhead than space-optimized Bloom filters. Cuckoo filters were first described in 2014. A cuckoo filter uses a 4-way set-associative hash table based on cuckoo hashing to store the fingerprints of all items. Particularly, the two potential buckets in the table for a given item formula_1 required by cuckoo hashing are calculated by the following two hash functions (termed as "partial-key cuckoo hashing"): Applying the above two hash functions to construct a cuckoo hash table enables item relocation based only on
15233783
Rendezvous hashing


yields the highest hash value. If a new site "S" is added, new object placements or requests will compute "n+1" hash values, and pick the largest of these. If an object already in the system at "S" maps to this new site "S", it will be fetched afresh and cached at "S". All clients will henceforth obtain it from this site, and the old cached copy at "S" will ultimately be replaced by the local cache management algorithm. If "
1215080
Bloom filter


element is If "k" is the number of hash functions and each has no significant correlation between each other, then the probability that the bit is not set to 1 by any of the hash functions is If we have inserted "n" elements, the probability that a certain bit is still 0 is the probability that it is 1 is therefore Now test membership of an element that is not in the set. Each of the "k" array positions computed by the hash functions is 1 with a probability as above
19284905
Challenge–response authentication


"N + 1", proving that the other end was able to decrypt the integer "N". In other variations, a hash function operates on a password and a random challenge value to create a response value. Such encrypted or hashed exchanges do not directly reveal the password to an eavesdropper. However, they may supply enough information to allow an eavesdropper to deduce what the password is, using a dictionary attack or brute-force attack. The use of information which is randomly generated on each exchange (and where
19593987
Cryptographic hash function


mathematical meaning, such as "not solvable in asymptotic polynomial time". Such interpretations of "difficulty" are important in the study of provably secure cryptographic hash functions but do not usually have a strong connection to practical security. For example, an exponential time algorithm can sometimes still be fast enough to make a feasible attack. Conversely, a polynomial time algorithm (e.g., one that requires "n" steps for "n"-digit keys) may be too slow for any practical use. An illustration of the potential use of a
4875712
Cycle sort


be addressed: The following Python implementation performs cycle sort on an array, counting the number of writes to that array that were needed to sort it. When the array contains only duplicates of a relatively small number of items, a constant-time perfect hash function can greatly speed up finding where to put an item, turning the sort from Θ("n") time to Θ("n" + "k") time, where "k" is the total number of hashes. The array ends up sorted in the order of the
491910
2-choice hashing


table; both hash functions map to locations on that table. The most important functions of the hashing implementation in this case are insertion and search. As is true with all hash tables, the performance is based on the largest bucket. Although there are instances where bucket sizes happen to be large based on the values and the hash functions used, this is rare. Having two hash functions and, therefore, two possible locations for any one value, makes the possibility of large buckets even more unlikely to happen. The expected
12791929
Jemmis mno rules


q rule, ferrocene requires, 2+11+1+2-0=16 SEPs. 10 CH units provide 15 pairs; Fe provides one pair. Thus a total of 16 SEPs are available, which satisfies m+n+o+p-q rule. BH is a bis-nido edge-shared polyhedron. Here, m+n+o+p-q = 2+18+0+2-0 = 22; 16 BH units provide 16 pairs; 4 bridging hydrogen atoms provide 2 pairs; two shared boron atoms provide 3 pairs; along with the
17447256
Hash table


guarantees that any key's hash, once issued, will never change, even when the hash table is later grown. Linear hashing is a hash table algorithm that permits incremental hash table expansion. It is implemented using a single hash table, but with two possible lookup functions. Another way to decrease the cost of table resizing is to choose a hash function in such a way that the hashes of most values do not change when the table is resized. Such hash functions are prevalent in disk-based and distributed hash tables
13843746
Associative array


advantages and weaknesses. The worst-case performance of self-balancing binary search trees is significantly better than that of a hash table, with a time complexity in big O notation of O(log "n"). This is in contrast to hash tables, whose worst-case performance involves all elements sharing a single bucket, resulting in O("n") time complexity. In addition, and like all binary search trees, self-balancing binary search trees keep their elements in order. Thus, traversing its elements follows a least
10837818
Rabin–Karp algorithm


, fixed length patterns in a text, a simple variant of the Rabin–Karp algorithm uses a Bloom filter or a set data structure to check whether the hash of a given string belongs to a set of hash values of patterns we are looking for: function RabinKarpSet(string s[1..n], set of string subs, m): We assume all the substrings have a fixed length "m". A naïve way to search for "k" patterns is to repeat a single-pattern search taking O("n+m") time
11545266
Hash-based cryptography


different circumstances. Leslie Lamport invented hash-based signatures in 1979. The XMSS (eXtended Merkle Signature Scheme) and SPHINCS hash-based signature schemes were introduced in 2011 and 2015, respectively. XMSS is based both on Merkle's seminal scheme and on the 2007 Generalized Merkle Signature Scheme (GMSS). A multi-tree variant of XMSS, XMSS, was described in 2013. Hash-based signature schemes use one-time signature schemes as their building block. A given one-time signing key can only be used
4640418
Hash table


is that of scanning the entries of the selected bucket for the desired key. If the distribution of keys is sufficiently uniform, the "average" cost of a lookup depends only on the average number of keys per bucket—that is, it is roughly proportional to the load factor. For this reason, chained hash tables remain effective even when the number of table entries "n" is much higher than the number of slots. For example, a chained hash table with 1000 slots and 10,000 stored keys (load factor
13843715
Streaming algorithm


space where the ("hashedvalues") are recorded. The below algorithm then determines approximate cardinality of "A".If there are "N" distinct elements in a data stream. The previous algorithm describes the first attempt to approximate "F" in the data stream by Flajolet and Martin. Their algorithm picks a random hash function which they assume to uniformly distribute the hash values in hash space. Bar-Yossef et al. in introduced k-minimum value algorithm for determining number of distinct elements in data stream. They
18643689
Rabin–Karp algorithm


would be executed O("n") times (i.e. on every iteration of the loop). Because character-by-character comparison of strings with length "m" takes O(m) time, the whole algorithm then takes a worst-case O("mn") time. The key to the Rabin–Karp algorithm's performance is the efficient computation of hash values of the successive substrings of the text. The Rabin fingerprint is a popular and effective rolling hash function. The hash function described here is not a Rabin fingerprint, but it
11545260
Rendezvous hashing


a wide variety of applications, including mobile caching, router design, secure key establishment, and sharding and distributed databases. Rendezvous hashing solves the distributed hash table problem: How can a set of clients, given an object "O", agree on where in a set of "n" sites (servers, say) to place "O"? Each client is to select a site independently, but all clients must end up picking the same site. This is non-trivial if we add a "minimal disruption
1215071
Collision resistance


-1 bits). Since it must generate one of 2 outputs for each member of a much larger set of inputs, the pigeonhole principle guarantees that some inputs will hash to the same output. Collision resistance does not mean that no collisions exist; simply that they are hard to find. The "birthday paradox" places an upper bound on collision resistance: if a hash function produces "N" bits of output, an attacker who computes only 2 (or formula_1) hash operations on random input is likely to find
13254391
Hash function


not be true. Hash tables often contain only a small subset of the valid inputs. For instance, a club membership list may contain only a hundred or so member names, out of the very large set of all possible names. In these cases, the uniformity criterion should hold for almost all typical subsets of entries that may be found in the table, not just for the global set of all possible entries. In other words, if a typical set of "m" records is hashed to "n" table
13702554
Hash function


. In many cases, one can design a special-purpose (heuristic) hash function that yields many fewer collisions than a good general-purpose hash function. For example, suppose that the input data are file names such as FILE0000.CHK, FILE0001.CHK, FILE0002.CHK, etc., with mostly sequential numbers. For such data, a function that extracts the numeric part "k" of the file name and returns "k" mod "n" would be nearly optimal. Needless to say, a function that is exceptionally good
13702577
UMAC


having massive amounts of computer power does not help the attacker at all. If the recipient limits the amount of forgeries it accepts (by sleeping whenever it detects one), |"D"| can be 2 or smaller. Functions in the above unnamed hash-function family uses "n" multiplies to compute a hash value. UMAC is the first MAC specifically designed to use SIMD instructions. For speed, UMAC uses the NH hash-function family. The NH family halves the number of multiplications, which roughly translates to a two-
19890882
F2FS


. Then, F2FS scans the hash table in level #0 to find the dentry consisting of the file name and its inode number. If not found, F2FS scans the next hash table in level #1. In this way, F2FS scans hash tables in each level incrementally from 1 to "N". In each level F2FS needs to scan only one bucket determined by the following equation, which shows O(log(# of files)) complexity. In the case of file creation, F2FS finds empty consecutive slots that
4035631
PAQ


" to "n". Thus, if the current state is ("n" = 4, "n" = 4, last bit = 0) and a 1 is observed, then the new state is not ("n" = 4, "n" = 5, last bit = 1). Rather, it is ("n" = 3, n = 4, last bit = 1). Most context models are implemented as hash tables. Some small contexts are implemented as direct lookup
7241770
Hash function


" = "z" mod "n" (the remainder of "z" divided by "n"), or "h" = ("z" × "n") ÷ "N" (the value "z" scaled down by "n"/"N" and truncated to an integer), or many other formulas. These simple formulas will not do if the input values are not equally likely, or are not independent. For instance, most patrons of a supermarket will live in the same geographic area
13702572
Universal hashing


formula_39 for all formula_40 is also strongly universal for formula_41. Unfortunately, the same is not true of (merely) universal families. For example, the family made of the identity function formula_42 is clearly universal, but the family made of the function formula_43 fails to be universal. UMAC and Poly1305-AES and several other message authentication code algorithms are based on universal hashing. In such applications, the software chooses a new hash function for every message, based on a unique nonce for that message. Several hash table implementations are based on
10644402
Rabin–Karp algorithm


same hash value. If the hash values match, the pattern and the substring may not match; consequently, the potential match of search pattern and the substring must be confirmed by comparing them; that comparison can take a long time for long substrings. Luckily, a good hash function on reasonable strings usually does not have many collisions, so the expected search time will be acceptable. The algorithm is as shown: function RabinKarp(string s[1..n], string pattern[1..m]) Lines 2, 4, and 6 each
11545256
Content addressable network


The Content Addressable Network (CAN) is a distributed, decentralized P2P infrastructure that provides hash table functionality on an Internet-like scale. CAN was one of the original four distributed hash table proposals, introduced concurrently with Chord, Pastry, and Tapestry. Like other distributed hash tables, CAN is designed to be scalable, fault tolerant, and self-organizing. The architectural design is a virtual multi-dimensional Cartesian coordinate space, a type of overlay network, on a multi-torus. This n-dimensional coordinate space
15580515