Shuki Bruck's Top 25 Papers – A Playful Retrospective

Gibson & Bruck's "Next Reaction Method" – What if simulating chemistry was less slog and more sleight-of-hand? This paper says yes, pulling out an algorithmic magic trick for chemical kinetics. By using just one random draw per reaction event and a clever time-update scheme, it simulates huge reaction networks fast^[1]. The motivation was simple: Gillespie's brute-force method was slow for many channels, so why not skip unnecessary coin flips? The surprising result: a simulation that scales almost logarithmically with reaction count^[1]. It's as if a chaotic molecular soup suddenly started obeying an efficient to-do list. Future-shaping? Absolutely – this work powers modern systems biology, proving that even biochemical randomness can learn to hurry up and wait (only as needed). (Michael A. Gibson & Jehoshua Bruck, J. Phys. Chem. A)^[2][1]

Qian, Winfree & Bruck's test-tube brain – Who needs silicon? This paper builds a brain in a bottle – a small neural network made entirely of DNA! The team trained a DNA-based network to play a 4-person "guess who" game^[11][12]. You drop DNA strands encoding clues into a test tube, and the DNA circuits light up to identify the right scientist (Watson or Crick, perhaps?). The motivation was sci-fi delicious: can molecules think? They showed DNA can do pattern recognition, performing a simplified neural net computation via strand displacement cascades^[13][14]. The fun part is how surprisingly brainlike this molecular soup behaves – it does error-tolerant recall (identifying a person from partial info) just like we do^[15]. Future-shaping implications abound: it hints at smart diagnostics and biocomputers that might one day swim inside cells. In a clever tone: this work taught DNA a new party trick – mind-reading! – at least for a very small mind. (Lulu Qian, Erik Winfree & Jehoshua Bruck, Nature)^[11][12]

Levchenko, Bruck & Sternberg's MAPK modeling – Cells have organizer proteins (scaffolds) that hold kinases together for faster reactions – but this paper asks: could too much scaffolding be a bad thing? The team built a quantitative model of a MAPK cascade with a scaffold protein, revealing a Goldilocks effect: a medium scaffold concentration maximizes the signal, but too high or too low dampens it^[25][26]. Motivation: understand how scaffold proteins tune the shape of cell signaling responses. Key idea: scaffolds can both amplify signals (by co-locating enzymes) and attenuate them (if they sequester components in clumsy complexes). Indeed, the model shows an optimal scaffold amount for peak MAPK activation, with biphasic behavior – too much scaffold makes the response more linear and reduces the switch-like threshold behavior of the kinase cascade^[27][28]. The surprising implication is that a cell might regulate scaffold levels to modulate signaling dynamics (nature's dimmer switch). In witty terms, this work taught us that protein scaffolds are like salt in soup – a pinch helps, but too much spoils the flavor, giving cells a new knob to turn in signaling. (Andre Levchenko, Jehoshua Bruck & Paul W. Sternberg, PNAS)^[25][26]

Soloveichik, Cook, Winfree & Bruck's Chemical Computation Theory – Can a bunch of chemical reactions compute anything computable? Surprisingly, yes – this paper showed that well-designed chemical reaction networks (CRNs) are computationally universal (able to simulate a Turing machine)^[40]. The motivation was to formalize biology's information-processing: if cells compute with chemistry, what class of computations can they do? By mapping logic gates and memory to reactions, the authors proved any algorithm can, in principle, be realized as a series of chemical reactions^[40][41]. One key idea was the "molecular finite state machine" – using different molecular species' counts as bits and reactions as transition rules. They also studied the efficiency and robustness of such computations in a well-stirred solution. The implication is mind-bending: a test tube of reacting chemicals has the same computation power as your digital computer (though considerably slower!). It's a foundational result for DNA computing and synthetic biology, putting these on a rigorous footing. Cleverly put, they basically argued that test tubes can run programs – just with molecules bumping as logic operations. Future-shaping? Definitely: it underpins the theory of biocomputers that may solve problems where electronics falter. In a witty wrap-up: this paper confirmed that given enough reacting molecules, even "Dr. Jekyll's potion could solve Sudoku." (David Soloveichik et al., Natural Computing)^[40][41]

Boolean logic meets Fourier beats. This work asked: what functions can a simple neural net (threshold circuit) compute? The answer came from an unlikely instrument – harmonic analysis. They proved that a Boolean function is implementable by a low-degree polynomial threshold if and only if its Fourier spectrum behaves nicely (specifically, has small L1 norm). Equivalently, if the function's frequency components are all in tune (no heavy high-frequency noise), a perceptron can model it; if not, no single threshold will do. This insight separated threshold circuits from shallow AC^0 circuits (proving new lower bounds). It was delightfully surprising to use continuous Fourier tools on discrete circuits — a trick that later became central in learning theory. In playful terms, Bruck and Smolensky essentially turned the question "Can this neural net compute f?" into "Does f's spectrum hum a simple tune?" If yes, a perceptron can whistle that melody! This Fourier criterion demystified threshold logic and influenced decades of neural complexity results.

Bruck & Blaum's IEEE IT paper – This early work intriguingly connects perceptrons (one-layer neural networks) with coding theory. They studied functions on ${0,1}^n$ that can be represented both as parity check equations and as polynomial threshold functions. One highlight: they showed how certain error-correcting code properties (like the weight distribution) relate to the polynomial representation of the code's indicator function^[56][57]. The motivation was likely twofold: use neural network algorithms to decode/block codes, and use coding theory to understand neural nets' computational limits. It introduced methods to count solutions (codewords) via polynomial characterizations. In a sense, it was exploring the border of two worlds – whether a single-layer neural net could learn to decode a given error-correcting code or detect its codewords. This was novel because it mixed continuous analogies (neurons summing inputs) with discrete structures (binary codes). A playful summary: the paper asked "Can a perceptron be a codebreaker?" – showing some links but also implying the limitations. It set stage for later work on neural network decoding and on using learning theory for codes. (Jehoshua Bruck & Mario Blaum, IEEE Trans. Info. Theory)

Bruck & Goodman's Journal of Complexity note – Early neural nets were biologically inspired, but could they crack NP-hard problems? This paper examined whether analog neural networks might circumvent brute-force search. They provided evidence that even with analog values, certain NP-hard problems (like boolean satisfiability) remain intractable for networks unless they grow exponentially^[60]. Essentially, it tempered the hype that a massively parallel "brain style" computer would magically solve NP-hard tasks efficiently. The analysis likely involved energy landscapes and local minima – showing neural nets get stuck just like any other algorithm on tough combinatorial puzzles. The motivation was both practical and philosophical: to understand limitations of brain-like computation. Their conclusion (informally): no free lunch – neurons don't get to cheat NP-hardness. In fun terms, they asked "Can a brain (or a neural net) instantly solve what puzzles our best computers?" and found the answer leaning negative. It's a reminder that while neural networks are powerful (as later AI booms showed), when it comes to the theoretical hardest problems, they likely won't be poly-time wizards. This work seeded later research on neural network computing models and complexity, showing Bruck's team was pondering AI vs complexity long before it was cool. (Jehoshua Bruck & Joseph W. Goodman, Journal of Complexity)

The RAIN Cluster Patent – Take the idea of RAID (redundant disks) and apply it to entire computers – that's RAIN in a nutshell. Bruck's team envisioned a cluster that never says die: an array of nodes with built-in redundant communication links and distributed data storage^[3][4]. If one node or network path fails, others seamlessly take over – a "hive mind" server that self-heals and keeps serving data. The key motivation was to build highly available web and media servers without the single points of failure in traditional setups^[5][6]. The clever part? Using only commodity PCs and dual networks, they achieved tolerance to multiple failures via smart reconfiguration protocols^[7][8]. This patent-pending paradigm was future-shaping: it foreshadowed modern cloud clusters and edge computing reliability. In short, Bruck's RAIN taught networks to sing in the rain – with backup nodes harmonizing whenever one goes silent.

Blaum, Brady, Bruck & Menon's RAID-6 Code – Hard drives crash – sometimes two at a time – so how do we save the data without overly complex math? Enter EVENODD, a brilliantly simple RAID-6 code that laughs in the face of two disk failures. Motivation: Reed-Solomon codes could handle double failures but were slow and required finite-field math. EVENODD instead uses just XOR parity (bitsy arithmetic) across disks^[17][18]. With two cleverly structured redundant disks, any two failed disks can be rebuilt by XOR'ing the survivors^[17][19]. It's optimal in storage (only 2 extras) and much faster to compute than Reed-Solomon – in a 15-disk array it's about half the computation^[20][21]. The key idea is a diagonal parity pattern (one even, one odd – hence "EVENODD") that makes reconstruction algebra super clean. This work was future-shaping: it directly influenced industry RAID controllers^[18]. In short, EVENODD is the cool kid of RAID codes – double-fault tolerant without breaking a sweat, just XORing its way through disk disasters. (Mario Blaum et al., IEEE Trans. Computers)^[17][18]

Xu & Bruck's Two-Dimensional Parity Code – To protect data on disks, you want maximum resilience with minimum fuss. X-Code is a clever 2D parity scheme that achieves Maximum Distance Separable (MDS) protection (tolerating two disk failures) with just XORs – and it's as encoding-efficient as possible^[18][20]. The code arranges data in a grid and computes parity both row-wise and diagonal-wise (sound familiar? it's like EVENODD's sibling). The motivation was to design a RAID-6 code that's both optimal in redundancy and easy to update on small writes^[29]. The key idea: by structuring parity in a cross pattern ("X" shape across the array), you can update one parity with only one data element's change, achieving optimal encoding complexity^[29]. The surprising implication is that you don't need heavy algebra for top-notch disk protection – simple XOR patterns suffice. In a playful sense, X-Code showed that even parity bits can have style – forming an X that saves your data with minimal effort. (And yes, the X really marks the spot of reliability!). (Lihao Xu & J. Bruck, IEEE Trans. Info. Theory)^[29]

Jiang, Mateescu, Schwartz & Bruck's Order-Based Storage – How can we store data in flash memory without wearing it out? This paper's answer: store information in the relative ranks of cell charges rather than absolute levels^[32]. In rank modulation, if cell A has a higher charge than cell B, that's a "1"; swap the order, it's a "0". The motivation was to combat flash cells' limitations: they're much easier to compare or increment than to precisely set or erase. The key idea: use permutations as codewords – data is encoded in a ranking of cells' charge levels^[32]. This means writing data by shuffling charges (using only "push-to-the-top" operations) without needing a hard reset of each cell^[32]. The surprising implication is a new coding theory for flash – error-correcting codes become combinatorial objects dealing with permutations (to handle errors like charge drift or rank swaps). In a fun tone: it's like storing messages in a line of people by height order instead of actual height – you only care who's tallest, second tallest, etc. Future-shaping wise, this concept launched an entire subfield of flash coding. It taught us that sometimes the order of things matters more than the things themselves, at least for flash memory longevity. (Anxiao (Andrew) Jiang et al., IEEE Trans. Info. Theory)^[32]

Tamo, Wang & Bruck's Repair-Efficient RAID Codes – If a storage node fails, how much data do we need to read from others to rebuild it? For traditional codes, quite a lot – but Zigzag codes minimize this repair traffic to the theoretical limit. The motivation here was large distributed storage (think data centers) where rebuilding a lost disk quickly and with minimal network load is crucial. Zigzag codes are MDS (maximum fault-tolerant) codes that achieve optimal rebuilding ratio: when one disk fails, you only need to read 1/(n-k) of the data from each of the other disks, evenly, to recover it^[37]. The key idea was a novel algebraic code construction where data symbols are mixed (zigzagged) across parity in just the right way to allow partial reads for repair^[37]. The surprising twist: these codes meet the cut-set bound for repair efficiency – they're as good as theoretically possible, improving rebuild speed and reducing bandwidth by a huge factor in large arrays. Playfully, it's like losing one piece of a complex puzzle but only having to look at a small corner of each of the other pieces to reconstruct it. Future-shaping indeed – Zigzag codes set a new bar for erasure codes in distributed storage, proving that fault tolerance can dance with efficiency in a zigzag pattern. (Itzhak Tamo, Zhiying Wang & J. Bruck, IEEE Trans. Info. Theory)^[37]

Alon, Bruck, Naor, Naor & Roth's Expander Codes – In coding theory, two things were long thought at odds: very low rate (lots of redundancy) and asymptotically vanishing error probability. Enter expander graphs – this team used them to construct error-correcting codes that beat that trade-off^[38]. The motivation was to explicitly build linear codes approaching the Shannon limit for low code rates (where classical algebraic codes struggled). The key idea: use a bipartite expander graph to connect bits and parity checks so that even a small fraction of errors gets spread out and caught by the checks^[39]. These expander codes had two superpowers: they are good (non-zero rate and relative distance) and have efficient iterative decoding algorithms. It was surprising and novel in 1992 – a field dominated by algebraic codes saw a discrete math approach yield competitive (and conceptually simple) codes. This work was a precursor to modern LDPC codes, showing that randomness and graph expansion can produce high-performance codes with simple XOR-based decoding. In a playful summary: they basically taught error-correcting codes to play "six degrees of Kevin Bacon" – every bit is connected through a pseudo-random network, so no bit can hide an error without a neighbor noticing^[39]. This paper bridged combinatorics and coding, seeding a revolution in coding theory. (Noga Alon et al.*, IEEE Trans. Info. Theory)*^[39]

Blaum, Bruck & Vardy's Triple-Star Code – Here the goal was ultra-reliable storage codes where each parity piece acts independently. They developed array codes (for RAID-like systems) that are MDS (optimal fault-tolerant) while arranging parity in a way that multiple parity disks don't interfere. The code, often dubbed the "Blaum-Bruck-Vardy (BBV) code," uses independent parity groups such that each parity symbol is computed from a subset of data symbols without overlap^[42]. Motivation: simplify encoding/decoding by decoupling parity calculations, making hardware implementations simpler and modular. The key idea was to use a bitmatrix (or graph) design where each parity bit sees a disjoint portion of the data – almost like multiple EVENODD stripes interleaved. The result: a family of RAID-6 codes that are flexible in code length and easy to scale, with low complexity. The surprising aspect is they achieved high fault tolerance with sparser parity relations ("low-density parity"), foreshadowing LDPC-like structures in array codes. In plain terms, BBV codes showed that two (or more) parrots squawking separately can still perfectly describe the whole data set – you don't need one giant equation when independent ones suffice. This work influenced later high-performance erasure codes in storage. (Mario Blaum, J. Bruck & Alexander Vardy, IEEE Trans. Info. Theory)^[42]

Xu, Bohossian, Bruck & Wagner's Graph-Based Codes – This paper lives at the intersection of coding theory and graph theory. It constructs MDS codes (optimal erasure correction) using factorizations of complete graphs^[45]. Imagine $K_{m}$, a complete graph on $m$ nodes – a perfect structure of connections. They showed that by taking certain 1-factors (perfect matchings) and associating them with parity equations, one can build an MDS array code where each parity involves only a fraction of data symbols (hence low-density)^[45]. Motivation: get reliable codes that are easier to update (each parity check is sparse). The neat result: they found conditions on $m$ (often prime-related) where you can decompose the complete graph into disjoint matchings that correspond to independent parity checks – ensuring two any missing data pieces can be recovered. In plain terms, it's like pairing up data bits in all possible ways across rounds to mix redundancy without overloading any single parity. The surprise is that such graph factors yield maximum-distance separable codes, marrying combinatorial design with optimal error correction. A witty angle: the work showed that even "social networking" among data bits via a complete graph can lead to perfectly reliable gossip" – every bit's secret can be reconstructed from the others' whispers if two bits go missing. (Lihao Xu et al.*, IEEE Trans. Info. Theory)*^[45]

Blaum & Bruck's IEEE IT paper – Parallel links are great – until their bits arrive out-of-sync (skewed), threatening data integrity. This paper presented a coding scheme that laughs at skew: it corrects misalignment by cleverly inserting redundancy across parallel channels^[50][51]. The scenario: multiple bits transmitted simultaneously over separate wires may not arrive simultaneously due to skew. Instead of expensive resynchronization hardware, they devised a skew-correcting code that tolerates certain bit-shifts between channels. The key idea was to treat skew as a special kind of erasure/burst and design a block code (with extra "frame" bits and parity) that can recover the original data despite relative delays up to a certain bound^[52]. In essence, they added just enough redundancy so that even if some bits from one channel slip into the next time slot, the decoder can put Humpty Dumpty back together. The surprising bit: they achieved this with linear codes that aren't too complex, proving that you can trade a little bandwidth for a lot of timing forgiveness. In plain terms, they made parallel buses "skew-tolerant" – like a chorus singing slightly out of sync but with a smart composer who can still reconstruct the perfect harmony. This was practically relevant for high-speed memory and interconnect design in the '90s. It's a fun reminder that sometimes engineering problems (timing skew) can be solved with math (coding) rather than more engineering. (Mario Blaum & J. Bruck, IEEE Trans. Info. Theory)

Blaum, Bruck, Khachatrian et al.'s IBM Journal work – Building on skew correction, this piece extended the theory to both detect and correct skew. It provided explicit code constructions for various skew lengths and a unified framework. The involvement of combinatorial design (enter Levon Khachatrian) hinted at deeper structure: they used ideas from finite geometry to design codewords that remain unambiguous under shifted alignments^[53][54]. The "skew-detecting" part means the system can tell when timing misalignment has occurred beyond allowable bounds (like a fail-safe alarm), while "skew-tolerant" codes actually correct moderate skew. The motivation was high-speed chip-to-chip links where clocks might drift – detection gives a chance to re-calibrate, correction handles small drifts automatically. A playful view: if the previous entry was making the chorus sing in harmony despite slight delays, this one is adding a conductor who not only fixes minor offbeats but also waves a flag if someone falls completely off tempo. Technically, they showed how to get the best of both worlds: maximum data rate and robustness, by blending error-correcting capability with error-detection flags. This further cemented that timing issues can be elegantly handled in the code layer. (Mario Blaum, J. Bruck, Levon Khachatrian, IBM Research Report / IEEE Trans. IT*)*

Bruck & Naor's IEEE IT paper – This theoretical gem tackled a cryptographer's daydream: "What if I preprocess a linear code with some extra smarts – does decoding become easy?" Bruck and Naor answered: Nope! They proved that even if you're allowed an arbitrary polynomial-time preprocessing (independent of the specific codeword to decode), the general decoding problem stays NP-hard^[55][56]. In simpler terms, no amount of clever indexing or lookup tables (of feasible size) will circumvent the exponential worst-case of decoding random linear codes – unless NP=coNP or other miracles occur. The motivation was to understand the inherent complexity of error-correction: could one separate the code structure in a one-time effort to then quickly decode any received message? Their result, using complexity-theoretic assumptions, suggests a strong security of certain codes (this paper is often cited in coding-based cryptography contexts). It was surprising in that it formally dashed hopes of a free lunch – even with a head start, decoding doesn't fundamentally simplify. Witty take: they basically said "You can't cheat on the decoding exam by studying ahead – it's just as hard when the test comes." This result stands as a cornerstone in complexity theory applied to coding, reinforcing why turbo/LDPC codes (with their heuristic decoders) were such big deals: they skirt NP-hardness by being probabilistic and not worst-case. (Jehoshua Bruck & Moni Naor, IEEE Trans. Info. Theory)

How do you encode data so it can lose k bits and still be recovered? This paper finally cracked a 50-year-old riddle posed by Levenshtein in 1966 [authors.library.caltech.edu]. Levenshtein showed one deletion is fixable with a clever code (the VT code) and conjectured the redundancy needed for k deletions is on the order of k·log n. Bruck and Sima swooped in and achieved that order with a concrete construction [authors.library.caltech.edu]. They designed a k-deletion correcting code with only about 8k·log n extra bits and an algorithm that can decode even after k bits vanish [authors.library.caltech.edu]. In essence, they built an efficient Humpty Dumpty protocol for data: no matter which k bits fall off the sequence, the code can figure out where the holes are and what filled them. The surprise was that they reached the theoretical limit of efficiency, solving a long-open problem with a dash of combinatorial ingenuity. It's like encoding a message such that even if a few characters get randomly zapped, the story still reads perfectly – a little coding magic that turned "impossible" into done.

Blaum & Bruck's creative decoding – The Golay code is famous – a perfect code correcting 3 errors – but usually decoded with heavy algebra. These authors showed a refreshingly low-tech method: use three overlaying Venn diagrams to decode!^[58][59] They leveraged the code's structure (particularly the fact it's length 23 and can be split into overlapping subsets) to create a visual decoding algorithm. Each region of the triple Venn corresponds to a specific parity check combination. By placing received bits into the diagram and inspecting certain shaded areas, one can identify the error pattern. This was motivated by making decoding more intuitive (perhaps for teaching or implementation): a majority logic/visual approach instead of brute-force. The idea that a complex code could succumb to a pictorial solution was surprising and fun. In effect, they turned a formidable mathematical object into a puzzle that could be solved by drawing circles and marking X's – almost like a Sudoku. A witty takeaway: even hard codes have a soft side – the Golay code secretly wanted to be decoded by a doodle. While not broadly applicable, this work exemplified Bruck's knack for out-of-the-box simplicity, finding structure in complexity (and it gave future engineers a neat party trick for decoding Golay by hand!). (Mario Blaum & Jehoshua Bruck, IEEE Trans. Info. Theory)

Bruck, Ho, Kipnis, Upfal's Communication Optima – In a parallel computer, when every processor needs to send data to every other, you've got an "all-to-all" party – but how to schedule the exchanges without a traffic jam? This paper delivered a set of index exchange algorithms that orchestrate all-to-all communication with optimal throughput^[33]. The motivation was practical: on early multicomputers (like IBM SP and Intel Paragon), each node had multiple network ports – how to exploit them fully for collective communication? Bruck & co. devised parameterized algorithms that gracefully trade off latency and bandwidth, achieving theoretical optimality for various network sizes^[33]. The key insight was to use clever indexing and dimensional scheduling so that each port is busy in a balanced way, avoiding collisions. The surprising bit: their schemes are topology-independent – they work well regardless of network layout, which was great for portable MPI implementations. In short, this work let supercomputer nodes gossip efficiently and in harmony, making sure no port sits idle while others overload. Playfully, it's like giving every student in class a perfectly timed script so they can all whisper secrets to each other at once without confusion. (J. Bruck et al., IEEE TPDS)^[33]

Bruck, Bohossian, Fan, LeMahieu & Love's RAIN Networking – Ever wish your server cluster could intelligently juggle network traffic and never drop the ball? This work presents a distributed cluster architecture that not only stores data reliably (a la RAIN) but also smartly load-balances network flows. The patent describes a cluster of nodes that collectively act as a highly available traffic manager – think of it as a fault-tolerant software-defined switch before that was cool. The system has redundant nodes and network links, plus a control GUI for managing it (hence "with graphical user interface"). The motivation was to create an internet traffic controller (for routing, firewalling, etc.) that wouldn't go down if any one box did^[30][31]. The clever part was integrating load distribution algorithms with the reliable cluster: the nodes share state so that if one fails, another transparently takes over its connections^[30][6]. Surprising implication: you get telco-grade reliability on cheap hardware, with a single virtual IP serviced by a resilient cluster. In a playful sense, this cluster is like a team of jugglers tossing network packets around – if one juggler trips, another instantly swoops in, packets still flying, audience none the wiser. (Patent US6691165) (Jehoshua Bruck et al., Patent filed 2000, granted 2004)

Bruck, Gao & Jiang's Geometric Routing – Suppose tiny sensors are scattered with no GPS – can they figure out where they are and route messages cleverly? This paper says yes: even if each node only knows the angles to neighboring nodes, it can achieve global coordinate-free localization and geometric routing^[46]. The motivation was to avoid expensive GPS or global coordinates in sensor networks by using purely local relationships. They introduced the idea that if each node measures the angle between its neighbors (essentially local geometric configuration), one can reconstruct a consistent coordinate embedding (up to similarity) for the network^[46]. Using this, they proposed a routing algorithm "LABAR" (Local Angle Based Routing) that greedily forwards packets toward the destination's angular sector, achieving good delivery rates without full position info. The surprising insight: local angle data (a very minimal sensing) is enough to infer substantial global structure – nodes can become aware of relative direction to far-away nodes' neighborhoods. In effect, they showed sensors could MacGyver their way to a map using angle scraps. The future impact is in low-cost deployment of sensor swarms: you can navigate and coordinate them with on-board compasses rather than satellite fixes. Playfully, this is like teaching a lost hiker to navigate using only a compass and the stars (neighbors), and still somehow draw a map of the terrain. (J. Bruck, Jie Gao & Anxiao Jiang, ACM TOSN)^[46].

Standley, Bao, Zhang, Bruck, Lau & Bockrath's 1-Atom Memory – Why use bulky transistors when you can make a switch out of a single atomic layer? This paper demonstrated a non-volatile memory switch using a tiny break in a graphene sheet^[34]. Two graphene electrodes separated by about a nanometer form a gap that can be dynamically bridged by molecules or filaments – toggling the conductive state. The motivation was to explore graphene for ultra-dense memory: they managed to create an on/off switch the size of a few atoms, essentially a memristor made of carbon. The key result was showing that the gap could repeatedly open and close (by applying voltage pulses) to switch between high and low resistance states^[34]. In doing so, they uncovered graphene's ability to form atomic-scale junctions that are stable and reconfigurable – a surprise at the time. The implications are futuristic: data storage or logic circuits could be built on single-layer carbon with switching regions only a billionth of a meter across! In a fun perspective, it's as if the researchers trained a sheet of graphene to play "red light, green light" at the quantum scale – stopping and flowing electrons on command. (Brian Standley et al., Nano Letters)

Boolean logic meets Fourier beats. This work asked: what functions can a simple neural net (threshold circuit) compute? The answer came from an unlikely instrument – harmonic analysis. They proved that a Boolean function is implementable by a low-degree polynomial threshold if and only if its Fourier spectrum behaves nicely (specifically, has small L1 norm). Equivalently, if the function's frequency components are all in tune (no heavy high-frequency noise), a perceptron can model it; if not, no single threshold will do. This insight separated threshold circuits from shallow AC^0 circuits (proving new lower bounds). It was delightfully surprising to use continuous Fourier tools on discrete circuits – a trick that later became central in learning theory. In playful terms, Bruck and Smolensky essentially turned the question "Can this neural net compute f?" into "Does f's spectrum hum a simple tune?" If yes, a perceptron can whistle that melody! This Fourier criterion demystified threshold logic and influenced decades of neural complexity results.[ SIAM Ebooks+1 | CaltechAUTHORS | ACM Digital Library]

Riedel and Bruck showed that you can sometimes close the loop in a "loop‑free" circuit and not break it. Conventional wisdom said combinational (memoryless) circuits must be acyclic, but they proved that carefully engineered feedback loops can remain stable and yield a valid combinational circuit. The payoff? Introduce cycles to potentially reduce circuit size or complexity – literally "thinking in circles" to simplify designs without introducing memory.

Bruck's team (with Yaakobi, Cassuto, et al.) revived a 1970s idea by Sheldon Akers – an array of logic cells that can compute any Boolean function – and gave it new life with memristors. They created a memristive Akers array where the same hardware serves as both memory and processor, blurring the line between storage and computing. The surprising result was a memory that can also perform logic operations on the data it stores. This in‑memory processing slashes the need to shuffle data back‑and‑forth to a separate CPU, hinting at a non‑von Neumann future of faster, energy‑efficient computing.[CaltechAUTHORS | Kolodny]

Wilhelm and Bruck took a daring step further – making circuits probabilistic on purpose. Instead of deterministic logic gates, they used coin‑flip "p‑switches" that output 1 with a certain probability. They developed algorithms to synthesize circuits that compute with randomness, even constructing a "universal probability generator" that turns fixed inputs into any desired probability distribution. This is like giving hardware a sense of chance, useful for modeling biological neural randomness or for hardware random number generation.

^{[1] [2]} Efficient Exact Stochastic Simulation of Chemical Systems with Many Species and Many Channels
https://authors.library.caltech.edu/records/zkvwc-5wc86
^{[3] [4] [5] [6] [7] [8] [9] [10] [30] [31]} US6088330A - Reliable array of distributed computing nodes - Google Patents
https://patents.google.com/patent/US6088330A/en
^{[11] [12] [13] [14] [15] [16]} First artificial neural network created out of DNA: Molecular soup exhibits brainlike behavior | ScienceDaily
https://www.sciencedaily.com/releases/2011/07/110720142501.htm
^{[17] [18] [19] [20] [21]} EVENODD: An Efficient Scheme for Tolerating Double Disk Failures in RAID Architectures
https://authors.library.caltech.edu/records/4azcy-f4q81
^{[22] [23] [24]} people.eecs.berkeley.edu
https://people.eecs.berkeley.edu/~culler/cs252-s02/papers/p245-blaum.pdf
^[25] Scaffold proteins may biphasically affect the levels of mitogen-activated protein kinase signaling and reduce its threshold properties
https://authors.library.caltech.edu/records/pv9g2-e7t51
^{[26] [27] [28]} Scaffold proteins may biphasically affect the levels of mitogen-activated protein kinase signaling and reduce its threshold properties - PMC
https://pmc.ncbi.nlm.nih.gov/articles/PMC18517/
^{[29] [32] [33] [37] [38] [39] [61]} Shuki's Research – Celebrate Shuki
https://shukibruck.com/shukis-research/
^[34] Graphene-Based Atomic-Scale Switches | Request PDF
https://www.researchgate.net/publication/23196054_Graphene-Based_Atomic-Scale_Switches
^[35] Metal oxide-resistive memory using graphene-edge electrodes - PMC
https://pmc.ncbi.nlm.nih.gov/articles/PMC4598621/
^[36] [PDF] Scaling limits of graphene nanoelectrodes - arXiv
https://arxiv.org/pdf/1702.05668
^{[40] [41] [42] [45] [46] [47]} ‪Jehoshua Bruck‬ - ‪Google Académico‬
https://scholar-google-com-443.webvpn.hdu.edu.cn/citations?user=HgaNy9kAAAAJ&hl=pt-PT
^{[43] [44]} Polynomial Threshold Functions, AC^0 Functions and Spectral Norms
https://authors.library.caltech.edu/records/ebydz-kpv88
^{[48] [49]} ERK Signals: Scaffolding Scaffolds? - PMC
https://pmc.ncbi.nlm.nih.gov/articles/PMC4885846/
^[50] Publications - IBM Research
https://research.ibm.com/publications?author=9203&page=7
[51] Bruck, Jehoshua - Library Feeds - Caltech
https://feeds.library.caltech.edu/people/Bruck-J/article.html
^[52] On Duplication-Free Codes for Disjoint or Equal-Length Errors - OUCI
https://ouci.dntb.gov.ua/en/works/4EjrK3ql/
^[53] Constructions of skew-tolerant and skew-detecting codes - Technion ...
https://cris.technion.ac.il/en/publications/constructions-of-skew-tolerant-and-skew-detecting-codes-2
^[54] Coding for Skew-Tolerant Parallel Asynchronous Communications ...
https://research.ibm.com/publications/coding-for-skew-tolerant-parallel-asynchronous-communications
^{[55] [56] [57] [58] [59] [60]} Jehoshua Bruck - Publications
http://academictree.org/math/publications.php?pid=344104
^[62] Jehoshua Bruck: Computer Science H-index & Awards - Academic Profile | Research.com
https://research.com/u/jehoshua-bruck