Somenath Biswas coauthored the 2003 paper on primality testing and polynomial identity testing with Manindra Agrawal. Their randomized algorithm reduces a candidate integer's primality to a univariate polynomial identity over the integers modulo that candidate.^[ref]

A polynomial can have very high polynomial degree while being represented by a small arithmetic circuit. Expanding every polynomial coefficient can then be impractical. The paper also gives randomized algorithms for multivariate polynomial identity testing with running time polynomial in the circuit representation size and an error parameter. The input representation and probability of error are consequently essential parts of the algorithmic statement.

Alexander A. Razborov coauthored Natural Proofs by Alexander A. Razborov and Steven Rudich with Steven Rudich. They analyzed why many successful restricted-model circuit lower bounds do not straightforwardly establish strong lower bounds for general Boolean circuits.^[ref]

Their framework separates a constructive property of Boolean functions, a large property of Boolean functions and a useful property against a circuit class. Together these can provide a statistical test contradicting a quantitatively strong pseudorandom function family assumption. The test for a constructive property of Boolean functions is measured against truth table size, not merely the number of input bits; that distinction is essential when stating the cryptographic hypothesis precisely.

Steven Rudich coauthored the natural proof framework with Alexander A. Razborov. Their 1997 paper identifies a barrier to a broad form of circuit lower bound argument, conditional on a sufficiently strong pseudorandom function family security assumption.^[ref]

A property that is efficiently recognizable from a truth table, holds for many random Boolean functions and excludes the target small-circuit class could distinguish pseudorandom function families from random ones. The required security must cover the time spent reading the entire table, which is exponential in the function's input length. The barrier restricts these proof methods under its assumption; it does not prove that circuit lower bounds are impossible.

Oded Goldreich coauthored the pseudorandom function family construction with Shafi Goldwasser and Silvio Micali. The construction uses a pseudorandom generator to expand a seed into two child seeds; successive input bits choose left or right children. Only the selected path is evaluated, so a short input can be processed without generating the whole tree.^[ref]

The result connects compact computation with a much larger implicit table of values. Security requires that efficient adaptive observers cannot distinguish this keyed table from a randomly chosen function, under the paper's computational assumptions.

Shafi Goldwasser coauthored How to Construct Random Functions by Oded Goldreich, Shafi Goldwasser and Silvio Micali. The paper formalizes pseudorandom function families through an observer's ability to distinguish keyed evaluation from access to one uniformly random function.^[ref]

The observer may choose later inputs after seeing earlier answers. Security therefore concerns the whole interaction, not just whether each separate output appears balanced. This computational experiment makes an apparently random reusable function a precise cryptographic object, conditional on the underlying hardness assumptions.

Silvio Micali coauthored the construction of pseudorandom function families with Oded Goldreich and Shafi Goldwasser. Their 1986 paper extends pseudorandomness from a generated binary string to a function that can be evaluated repeatedly at chosen inputs.^[ref]

A short key specifies an efficiently evaluated function even though its full truth table can be exponentially large. The comparison experiment is a single randomly chosen function, so repeated queries must receive consistent answers. That consistency distinguishes function security from supplying fresh independent random bits on every call.

Ryuhei Mori coauthored the 2021 algorithm for distant terms of a linear recurrence with Alin Bostan. Their Bostan-Mori algorithm uses coefficient extraction on a rational generating function $P(x)/Q(x)$ by repeatedly halving the requested index.^[ref]

Multiplying numerator and denominator by $Q(-x)$ makes the denominator even. Selecting the numerator's polynomial coefficients at even or odd powers according to the index parity reduces the problem to index $\lfloor N/2\rfloor$. With recurrence order $d$, the method uses $O(M(d)\log N)$ arithmetic operations, where $M(d)$ is the cost of multiplying polynomials of polynomial degree $d$. This reaches a distant term without computing every preceding term.

Paul C. van Oorschot coauthored the Handbook of Applied Cryptography by Alfred J. Menezes, Paul C. van Oorschot and Scott A. Vanstone. Its treatment connects cryptographic constructions with explicit mathematical algorithms and stated assumptions, rather than describing encryption only as a black box. The number-theoretic chapter includes algorithms for modular square roots, while the public-key chapter gives RSA cryptosystem and Rabin cryptosystem constructions.^[ref]

For a concrete special case, if $p\equiv 3(\mathrm{mod}4)$ is prime and $a$ is a nonzero square modulo $p$, a square root is $a^{(p+1)/4}\mathrm{mod}p$. This illustrates how assumptions on an integer modulus determine which algorithm and correctness argument apply.

J. A. Robinson introduced the resolution principle in his 1965 paper on machine-oriented logic. His clause-based resolution calculus, using unification, supports a complete refutation procedure for first-order logic: an unsatisfiable clause set has a derivation of the empty clause.^[ref]

For example, resolving $P(x)\vee Q(x)$ with $\neg P(a)$ uses the first-order substitution $x\mapsto a$ and produces $Q(a)$. The rule separates the logical justification of a step from the search for useful clauses. A complete search procedure can still run indefinitely on a satisfiable input; completeness does not supply a decision algorithm for all first-order logic.

Alberto Martelli coauthored An Efficient Unification Algorithm by Alberto Martelli and Ugo Montanari in 1982. With Ugo Montanari, he developed a term-equation algorithm whose acyclicity check is built into the implementation rather than treated as an expensive separate afterthought.^[ref]

Unification asks for a substitution making terms identical; the most general unifier captures every solution through further substitution. This is stronger than finding one arbitrary matching assignment. The paper's equation transformations preserve the solution set while detecting incompatible constructors and cyclic finite-term requirements, connecting a declarative specification to an efficient procedure.

Ugo Montanari coauthored the 1982 unification algorithm with Alberto Martelli. Their paper treats first-order terms as equations and derives an efficient implementation from simpler transformation rules, integrating the acyclicity test needed for finite terms.^[ref]

For example, decomposing $f(x,a)=f(b,y)$ gives $x=b$ and $y=a$, whereas $x=f(x)$ has no finite-term solution and must be rejected. The point is to compute a most general unifier without expanding or repeatedly traversing shared term structure unnecessarily. Such unification supports automated deduction and logic programming.

Alfred V. Aho coauthored Efficient String Matching: An Aid to Bibliographic Search by Alfred V. Aho and Margaret J. Corasick with Margaret J. Corasick in 1975. Their Aho-Corasick algorithm constructs a machine for a whole pattern dictionary and searches a text in a single pass.^[ref]

Its useful distinction is between text progress and pattern progress. On a failed extension, a failure link changes the candidate pattern prefix without moving backward in the text. Shared prefixes and suffix continuations avoid repeating a complete independent search for every keyword, while reporting cost still grows with the number of actual matches.

Margaret J. Corasick coauthored the 1975 multi-keyword matching algorithm with Alfred V. Aho. Their Aho-Corasick algorithm builds a finite-state keyword-matching machine and scans the text once, reporting occurrences of all dictionary patterns.^[ref]

A trie shares pattern prefixes, while failure links retain the longest useful suffix after a mismatch. For patterns he and she, reaching the end of she must also report he; terminal suffix information is therefore part of matching, not merely following trie edges. The mechanism makes one text scan reusable across many search terms.

E. F. Codd introduced the relational model in his 1970 paper on large shared data banks. Data is represented by relations rather than application-visible pointers and access paths, supporting data independence: changing physical organization need not change the meaning of a query.^[ref]

The distinction is operationally important. A query can request tuples satisfying a predicate while the system chooses an index or scan. Applications specify the information they need instead of navigating one fixed storage layout. Mathematical relations also expose dependencies among attributes, providing a foundation for database normalization.

Peter Pin-Shan Chen proposed the entity-relationship model in his 1976 paper. It represents the application world through entities, relationships and attributes, together with a diagrammatic method for database design. The model aims to preserve semantic distinctions before translating them into a particular database representation.^[ref]

For example, a relationship between an employee and a project can carry an hours-worked attribute. That quantity belongs to the participation relationship, not to the employee or project alone. Making its placement explicit helps avoid duplicating or misinterpreting facts when designing a relational schema.

The PostgreSQL Global Development Group is the collective project attribution used for the development and documentation of PostgreSQL, an open-source database management system. Its documentation specifies concrete behavior for database transactions, database integrity constraints, database query operations and storage mechanisms; these specifications are more precise than inferring behavior from SQL syntax alone.^[ref]

For example, PostgreSQL documents transaction isolation levels in terms of visible snapshots and permitted anomalies. The project name here identifies the responsible development community, rather than one individual author or a separate database product.

Roberto Grossi coauthored the 2003 entropy-compressed text-index paper with Ankur Gupta and Jeffrey Scott Vitter. The paper combines compressed suffix-array techniques with a wavelet tree, routing sequence positions through bitvectors that partition the alphabet. Its indexing bounds relate stored space to empirical entropy while retaining pattern-search functionality. The mathematical aim is both compression and access, rather than simply making a file small.^[ref]

Ankur Gupta is the coauthor named with Roberto Grossi and Jeffrey Scott Vitter on their 2003 entropy-compressed text-index paper. Its wavelet tree represents a sequence through alphabet partitions and bitvectors. Navigating a symbol uses rank queries to map positions between successive partitions, supporting operations on a compressed index. This contribution concerns searchable sequence representations; it does not identify this author with unrelated people sharing the same name.^[ref]

Jeffrey Scott Vitter coauthored the 2003 work on entropy-compressed text indexes with Roberto Grossi and Ankur Gupta. It develops compressed suffix-array representations and introduces a wavelet tree representation for symbol sequences. Bitvectors route a position through alphabet partitions, with rank queries translating that position into the selected subsequence. This connects compressed storage to efficient indexing rather than requiring full decompression for every query.^[ref]

Raimund Seidel coauthored Randomized Search Trees by Raimund Seidel and Cecilia R. Aragon with Cecilia R. Aragon. The paper analyzes search trees whose shape is governed by random priorities. Combining binary search tree order and heap order gives the treap, supporting searches, updates and split/join operations with expected bounds.^[ref]

The key idea is to analyze the distribution of the whole tree instead of enforcing a fixed local balance ratio after every update. For example, the item with highest priority becomes the root, and the same construction applies recursively to the smaller and larger keys. This turns priority independence into an analyzable balancing mechanism.