CaltechAUTHORS: Monograph
https://feeds.library.caltech.edu/people/Bruck-J/monograph.rss
A Caltech Library Repository Feedhttp://www.rssboard.org/rss-specificationpython-feedgenenFri, 02 Aug 2024 12:50:35 -0700Performance Optimization of Checkpointing Schemes with Task Duplication
https://resolver.caltech.edu/CaltechPARADISE:1994.ETR004
Year: 1994
Checkpointing schemes enable fault-tolerant parallel and distributed computing by leveraging
the redundancy in hardware and software resources. In these systems, checkpointing serves two
purposes: it helps in detecting faults by comparing the processors states at checkpoints, and
it facilitates the reduction of fault recovery time by supplying a safe point to rollback to. The
efficiency of checkpointing schemes is influenced by the time it takes to perform the comparisons
and to store the states. The fact that checkpoints consist of both storing of states and comparison
between states, with conflicting objectives regarding the frequency of those operations, limits
the performance of current checkpointing schemes.
In this paper we show that by tuning the checkpointing schemes to a given architecture, a
significant reduction in the execution time can be achieved. We will present both analytical
results and experimental results that were obtained on a cluster of workstations and a parallel
computer.
The main idea is to use two types of checkpoints: compare-checkpoints (comparing the states
of the redundant processes to detect faults) and store-checkpoints (storing the states to reduce
recovery time). With two types of checkpoints, we can use both the comparison and storage
operations in an efficient way and improve the performance of checkpointing schemes. As a
particular example of this approach we analyzed the DMR checkpointing scheme with store
and compare checkpoints on two types of architectures, one where the comparison time is much
higher than the store time (like a cluster of workstations connected by a LAN) and one where the
store time is much higher than the comparison time (like the Intel Paragon supercomputer). We
have implemented a prototype of the new DMR schemes and run it on workstations connected by
a LAN and on the Intel Paragon supercomputer. The experimental results we obtained match
the analytical results and show that in some cases the overhead of the DMR checkpointing
schemes on both architectures can be improved by as much as 40%.https://resolver.caltech.edu/CaltechPARADISE:1994.ETR004Analysis of Checkpointing Schemes for Multiprocessor Systems
https://resolver.caltech.edu/CaltechPARADISE:1994.ETR003
Year: 1994
Parallel computing systems provide hardware redundancy that helps to achieve low cost fault-
tolerance. Fault-tolerance is achieved, in those systems, by duplicating the task into more than one
processor, and comparing the states of the processors at checkpoints. Many schemes that achieve
fault tolerance exist, and most of them use checkpointing to reduce the time spent retrying a task.
Performance evaluation for most of the schemes either relies on simulation results, or uses a simplified
fault model.
This paper suggests a novel technique, based on a Markov Reward Model (MRM), for analyzing the
performance of checkpointing schemes for fault-tolerance. We show how this technique can be used to
derive the average execution time of a task and other important parameters related to the performance
of checkpointing schemes. Our analytical results match well the values we obtained using a simulation
program.
We compare the average task completion time and total work of four checkpointing schemes, TMR,
DMR-B-2, DMR-F-1 and RFCS. We show that generally increasing the number of processors reduces
the average completion time, but increases the total work done by the processors. Namely, the TMR
scheme, which uses three processors, is the quickest but does the most work, while the DMR-B-2 scheme,
which uses only two processors, is the slowest of the four schemes but does the least work. However,
in cases where there is a big difference between the time it takes to perform different operations, those
results can change. For example, when we assume that the schemes are implemented on workstations
connected by a LAN and the time to move data between workstations is relatively long, the DMR-B-2
scheme can become quicker than the TMR scheme.https://resolver.caltech.edu/CaltechPARADISE:1994.ETR003Fault-Tolerant Meshes with Small Degree
https://resolver.caltech.edu/CaltechPARADISE:1994.ETR001
Year: 1994
This paper presents constructions for fault-tolerant two-dimensional mesh
architectures. The constructions are designed to tolerate k faults while maintaining a healthy n
by n mesh as a subgraph. They utilize several novel techniques for obtaining trade-offs
between the number of spare nodes and the degree of the fault-tolerant network.
We consider both worst-case and random fault distributions. In terms of worst-case faults, we give a construction that has constant degree and O(k to the power of 3) spare nodes. This is
the first construction known in which the degree is constant and the number of spare
nodes is independent of n. In terms of random faults, we present several new degree-6
and degree-8 constructions and show (both analytically and through simulations) that
they can tolerate large numbers of randomly placed faults.https://resolver.caltech.edu/CaltechPARADISE:1994.ETR001On Neural Networks with Minimal Weights
https://resolver.caltech.edu/CaltechPARADISE:1995.ETR005
Year: 1995
Linear threshold elements are the basic building blocks of artificial
neural networks. A linear threshold element computes a function
that is a sign of a weighted sum of the input variables. The weights
are arbitrary integers: actually, they can be very big integers-
exponential in the number of the input variables. However, in
practice, it is difficult to implement big weights. In the present
literature a distinction is made between the two extreme cases:
linear threshold functions with polynomial-size weights as opposed
to those with exponential-size weights. The main contribution of
this paper is to fill up the gap by further refining that separation.
Namely, we prove that the class of linear threshold functions with
polynomial-size weights can be divided into subclasses according
to the degree of the polynomial. In fact we prove a more general
result-that there exists a minimal weight linear threshold function
for any arbitrary number of inputs and any weight size. To prove
those results we have developed a novel technique for constructing
linear threshold functions with minimal weights.https://resolver.caltech.edu/CaltechPARADISE:1995.ETR005Interleaving Schemes for Multidimensional Cluster Errors
https://resolver.caltech.edu/CaltechPARADISE:1995.ETR008
Year: 1995
We present 2 and 3-dimensional interleaving techniques for correcting 2 and 3-
dimensional bursts (or clusters) of errors, where a cluster of errors is characterized by its
area or volume. A recent application of correction of 2-dimensional clusters appeared
in the context of holographic storage. Our main contribution is the construction of
efficient 2 and 3-dimensional interleaving schemes. The schemes are based on arrays of
integers with the property that every connected component of area or volume t consists
of distinct integers (we call these t-interleaved arrays). In the 2-dimensional case, our
constructions are optimal in the sense that they contain the smallest possible number
of distinct integers, hence minimizing the number of codes required in an interleaving
scheme.https://resolver.caltech.edu/CaltechPARADISE:1995.ETR008An Online Algorithm for Checkpointing Placement
https://resolver.caltech.edu/CaltechPARADISE:1995.ETR006
Year: 1995
Checkpointing is a common technique for reducing the
time to recover from faults in computer systems. By saving
intermediate states of programs in a reliable storage,
check pointing enables to reduce the lost processing time caused
by faults. The length of the intervals between checkpoints
affects the execution time of programs. Long intervals lead
to long re-processing time, while too frequent checkpoint-
iizg leads to high checkpointing overhead. In this paper we
present an on-line algorithm for placement of checkpoints.
The algorithm uses on-line knowledge of the current cost
of a checkpoint when it decides whether or not to place a
checkpoint. We show how the execution time of a program
using this algorithm can be analyzed. The total overhead of
the execution time when the proposed algorithm is used is
smaller than the overhead when fixed intervals are used.
Although the proposed algorithm uses only on-line knowledge
about the cost of checkpointing, its behavior is close to the off-line optimal algorithm that uses a complete knowledge
of checkpointing cost.https://resolver.caltech.edu/CaltechPARADISE:1995.ETR006Fault-Tolerant Cube Graphs and Coding Theory
https://resolver.caltech.edu/CaltechPARADISE:1995.ETR007
Year: 1995
Hypercubes, meshes, tori and Omega networks are well known interconnection
networks for parallel computers. The structure of those graphs can be described in a
more general framework called cube graphs. The idea is to assume that every node in
a graph with q to the power of l (letter l) nodes is represented by a unique string of l (letter l) symbols over GF(q). The edges are specified by a set of offsets, those are vectors of length l (letter l) over GF(q), where the two endpoints of an edge are an offset apart. We study techniques for tolerating edge faults in cube graphs that are based on adding redundant edges. The redundant
graph has the property that the structure of the original graph can be maintained
in the presence of edge faults. Our main contribution is a technique for adding the
redundant edges that utilizes constructions of error-correcting codes and generalizes
existing ad-hoc techniques.https://resolver.caltech.edu/CaltechPARADISE:1995.ETR007A Coding Approach for Detection of Tampering in Write-Once Optical Disks
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR013
Year: 1996
We present coding methods for protecting against tampering of write-once optical
disks which turns them into a secure digital medium for applications where critical
information must be stored in a way that presents or allows detection of an attempt at
falsification. Our method involves adding a small amount of redundancy to a modulated
sector of data. This extra redundancy is not used for normal operation, but can be
used for determining, say as a testimony in court, that a disk has not been tampered
with.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR013Algebraic Techniques for Constructing Minimal Weight Threshold Functions
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR015
Year: 1996
A linear threshold element computes a function that is a sign of a weighted sum of the
input variables. The weights are arbitrary integers; actually, they can be very big integers-
exponential in the number of the input variables. While in the present literature a distinction is
made between the two extreme cases of linear threshold functions with polynomial-size weights
as opposed to those with exponential-size weights, the best known lower bounds on the size
of threshold circuits are for depth-2 circuits with small weights. Our main contributions are
devising two distinct methods for constructing threshold functions with minimal weights and
filling up the gap between polynomial and exponential weight growth by further refining the
separation. Namely, we prove that the class of linear threshold functions with polynomial-size
weights can be divided into subclasses according to the degree of the polynomial. In fact, we
prove a more general result-that there exists a minimal weight linear threshold function for
any arbitrary number of inputs and any weight size.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR015Multiple Threshold Neural Logic
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR010
Year: 1996
We introduce a new Boolean computing element, related to the Boolean version of a
neural element. Instead of the sign function in the Boolean neural element, (also known
as an LT element), it computes an arbitrary (with polynomialy many transitions) Boolean
function of the weighted sum of its inputs. We call the new computing element an LTM
element, which stands for Linear Threshold with Multiple transitions.
The paper consists of the following main contributions related to our study of LTM
circuits: (i) the characterization of the computing power of LTM relative to LT circuits,
(ii) a proof that the area of the VLSI layout, is reduced from O(n to the power of 2) in LT circuits to O(n) in LTM circuits, for n inputs symmetric Boolean functions, and (iii) the creation of efficient
designs of LTM circuits for the addition of a multiple number of integers and the product,
of two integers. In particular, we show how to compute the addition of m integers with a
single layer of LTM elements.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR010Efficient Digital to Analog Encoding
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR009
Year: 1996
NOTE: Text or symbols not renderable in plain ASCII are indicated by [...]. Abstract included in .pdf document.
An important issue in analog circuit design is the problem of digital to analog conversion,
namely, the encoding of Boolean variables into a single analog value which contains enough
information to reconstruct the values of the Boolean variables. A natural question is: What
is the complexity of implementing the digital to analog encoding function? That question was
recently answered in (5), where matching lower and upper bounds on the size of the circuit for
the encoding function were proven. In particular, it was proven that [...] 2-input arithmetic
gates are necessary and sufficient for implementing the encoding function of n Boolean variables.
However, the proof of the upper bound is not constructive.
In this paper, we present an explicit construction of a digital to analog encoder that is
optimal in the number of 2-input arithmetic gates. In addition, we present an efficient analog
to digital decoding algorithm. Namely, given the encoded analog value, our decoding algorithm
reconstructs the original Boolean values. Our construction is suboptimal in that it uses constants
[...] bits.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR009Optimal Constructions of Fault-Tolerant Multistage Interconnection Networks
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR014
Year: 1996
In this paper we discover the family of Fault-Tolerant Multistage Interconnection Networks
(MINs) that tolerates switch faults with a minimal number of redundant switching stages.
While previously known constructions handled switch faults by eliminating complete stages,
our approach is to bypass faulty switches by utilizing redundant paths. As a result, we
are able to construct the first known fault-tolerant MINs that are optimal in the number
of redundant stages. Our fault model assumes that a faulty switch can be bypassed and
our goal is to guarantee arbitrary point to point and broadcast connectivity. Under this
model, we show that to tolerate f switch faults the MIN must have at least f redundant
stages. We then present the explicit construction of a MIN that meets this lower-bound.
This construction repeatedly uses the singleton basis of the n-dimensional vector space as the
mask vectors of the MIN. We generalize this construction and prove that an n-dimensional
MIN is optimally fault-tolerant if and only if the mask vectors of every n consecutive stages
span the n-dimensional vector space.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR014On Optimal Placements of Processors in Tori Networks
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR012
Year: 1996
Two and three dimensional k-tori are among the most used topologies in the design of new
parallel computers. Traditionally (with the exception of the Tera parallel computer), these
networks have been used as fully-populated networks, in the sense that every routing node
in the topology is subjected to message injection. However, fully-populated tori and meshes
exhibit a theoretical throughput which degrades as the network size increases. In addition,
the performance of those networks is sensitive to link faults. In contrast, multistage networks
(that are partially populated) scale well with the network size. We propose to add slackness in
fully-populated tori by reducing the number of processors and we study optimal fault-tolerant
routing strategies for the resulting interconnections.
The key concept that we study is the average link load in an interconnection network with
a given placement and a routing algorithm, where a placement is the subset of the nodes in the
interconnection network that are attached to processors. Reducing the load on the links by the
choice of a placement and a routing algorithm leads to improvements in both the performance
and the fault tolerance of the communication system.
Our main contribution is the construction of optimal placements for 2 and 3-dimensional
k-tori networks and their corresponding routing algorithms. Those placements yield a linear (in
the number of processors) link load and are of optimal size.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR012Deterministic Voting in Distributed Systems Using Error-Correcting Codes
https://resolver.caltech.edu/CaltechPARADISE:1996.ETR011
Year: 1996
Distributed voting is an important problem in reliable computing. In an N
Modular Redundant (NMR) system, the N computational modules execute identical tasks
and they need to periodically vote on their current states. In this paper, we propose a
deterministic majority voting algorithm for NMR systems. Our voting algorithm uses
error-correcting codes to drastically reduce the average case communication
complexity. In particular, we show that the efficiency of our voting algorithm can be improved
by choosing the parameters of the error correcting code to match the probability of
the computational faults. For example, consider an NMR system with 31 modules,
each with a state of m bits, where each module has an independent computational
error probability of 10 to the power of minus 3. In this NMR system, our algorithm can reduce the average case communication complexity to approximately 1.0825m compared with the
communication complexity of 31m of the naive algorithm in which every module broadcasts
its local result to all other modules. We have also implemented the voting algorithm
over a network of workstations. The experimental performance results match well the
theoretical predictions.https://resolver.caltech.edu/CaltechPARADISE:1996.ETR011X-Code: MDS Array Codes with Optimal Encoding
https://resolver.caltech.edu/CaltechPARADISE:1997.ETR020
Year: 1997
We present a new class of MDS array codes of size n x n (n a prime number)
called X-Code. The X-Codes are of minimum column distance 3, namely, they can
correct either one column error or two column erasures. The key novelty in X-code is
that it has a simple geometrical construction which achieves encoding/update optimal
complexity, namely, a change of any single information bit affects exactly two parity
bits. The key idea in our constructions is that all parity symbols are placed in rows
rather than columns.https://resolver.caltech.edu/CaltechPARADISE:1997.ETR020Partial-Sum Queries in OLAP Data Cubes Using Covering Codes
https://resolver.caltech.edu/CaltechPARADISE:1997.ETR018
Year: 1997
A partial-sum query obtains the summation over a set of
specified cells of a data cube. We establish a connection
between the covering problem in the theory of covering codes
and the partial-sum problem and use this connection to
devise algorithms for the partial-sum problem with efficient
space-time trade-offs. For example, using our algorithms,
with 44% additional storage, the query response time can
be improved by about 12%; by roughly doubling the storage
requirement, the query response time can be improved by
about 34%.https://resolver.caltech.edu/CaltechPARADISE:1997.ETR018MDS Array Codes for Correcting Criss-Cross Errors
https://resolver.caltech.edu/CaltechPARADISE:1997.ETR019
Year: 1997
We present a family of MDS array codes of size (p - 1) x ( p - 1), p a prime number,
and minimum criss-cross distance 3, i.e., the code is capable of correcting any row
or column in error, without apriori knowledge of what type of error occurred. The
complexity of the encoding and decoding algorithms is lower than that of known codes
with the same error-correcting power, since our algorithms are based on exclusive-
OR operations over lines of different slopes. as opposed to algebraic operations over a
finite field. Tl'e also provide efficient encoding and decoding algorithms for errors and
erasures.https://resolver.caltech.edu/CaltechPARADISE:1997.ETR019Programmable Neural Logic
https://resolver.caltech.edu/CaltechPARADISE:1997.ETR017
Year: 1997
NOTE: Text or symbols not renderable in plain ASCII are indicated by [...]. Abstract is included in .pdf document.
Circuits of threshold elements (Boolean input, Boolean output neurons) have been
shown to be surprisingly powerful. Useful functions such as XOR, ADD and MULTIPLY
can be implemented by such circuits more efficiently than by traditional AND/OR cir-
cuits. In view of that, we have designed and built a programmable threshold element.
The weights are stored on polysilicon floating gates, providing long-term retention
without refresh. The weight value is increased using tunneling and decreased via hot electron
injection. A weight is stored on a single transistor allowing the development of dense
arrays of threshold elements. A 16-input programmable neuron was fabricated in the
standard 2 [...] double-poly, analog process available from MOSIS. A long term goal
of this research is to incorporate programmable threshold elements, as building blocks in
Field Programmable Gate Arrays.https://resolver.caltech.edu/CaltechPARADISE:1997.ETR017Two-Dimensional Interleaving Schemes with Repetitions
https://resolver.caltech.edu/CaltechPARADISE:1997.ETR016
Year: 1997
We present 2-dimensional interleaving schemes, with repetition, for correcting 2-
dimensional bursts (or clusters) of errors, where a cluster of errors is characterized by
its area. A recent application of correction of 2-dimensional clusters appeared in the
context of holographic storage. Known interleaving schemes are based on arrays of
integers with the property that every connected component of area t consists of distinct
integers. Namely, they are based on the use of 1-error-correcting codes. We extend this
concept by allowing repetitions within the arrays, hence, providing a trade-off between
the error-correcting capability of the codes and the degree of the interleaving schemes.https://resolver.caltech.edu/CaltechPARADISE:1997.ETR016A Leader Election Protocol for Fault Recovery in Asynchronous Fully-Connected Networks
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR024
Year: 1998
We introduce a new algorithm for consistent failure detection in asynchronous
systems. Informally, consistent failure detection requires processes in a distributed system to distinguish between two different populations: a fault free
population and a faulty one.
The major contribution of this paper is in combining ideas from group
membership and leader election, in order to have an election protocol for a
fault manager whose convergence is delayed until a new consistent view of the connectivity
of the network is established by all processes. In our algorithm a group of
processes agrees upon the failed population of the system, and then gives to a unique
leader, called the fault manager, the possibility of executing distributed tasks in
a centralized way.
This research and the new perspective that we propose are driven by the
study of an actual system, the Caltech RAIN (Reliable Array of Independent
Nodes), on which our protocol has been implemented in order to perform fault
recovery in distributed checkpointing. Other potential applications include fault
tolerant distributed database services and fault tolerant distributed web servers.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR024Tolerating Faults in Counting Networks
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR022
Year: 1998
Counting networks were proposed by Aspnes, Herlihy and Shavit [4] as a technique
for solving multiprocessor coordination problems. We describe a method for tolerating an
arbitrary number of faults in counting networks. In our fault model, the following errors can occur
dynamically in the counting network data structure: 1) a balancer's state is spuriously altered, 2)
a balancer's state can no longer be accessed.
We propose two approaches for tolerating faults. The first is based on a construction for a
fault-tolerant balancer. We substitute a fault-tolerant balancer for every balancer in a counting
network. Thus, we transform a counting network with depth O(log to the power of 2 n); where n is the
width, into a k-fault-tolerant counting network with depth O(k log to the power of 2 n).
The second approach is to append a correction network, built with fault-tolerant balancers, to a
counting network that may experience faults. We present a bound on the error in the output token
distribution of counting networks with faulty balancers (a generalization of the error bound for
sorting networks with faulty comparators presented by Yao & Yao [21]. Given a token distribution
with a bounded error, the correction network produces a token distribution that is smooth, i.e.,
the number of tokens on each output wire differs by at most one (a weaker condition than the
step property). In order to tolerate k faults, the correction network has depth O (k to the power of 2
log n) for a network of width n.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR022An Efficient Algorithm for Generating Trajectories of Stochastic Gene Regulation Reactions
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR026
Year: 1998
Systems of weakly coupled chemical equations occur in gene regulation and other biological
systems. For small numbers of molecules (as in a small cell), the usual differential equations
approach to chemical kinetics must be replaced with a stochastic approach. To deal with this
kind of system, one generates trajectories through stochastic phase space. By generating a large
enough number of trajectories, one can understand the statistics of the behavior of the complex,
non-linear system.
The algorithms for dealing with sparsely connected stochastic processes are not as advanced
as those for sparse deterministic processes. In particular. the existing algorithm of choice for
generating trajectories, which is not optimized in any way for sparseness, is O(rE), where r is
the number of reactions and E is the number of reaction events in the trajectory. \Ye present
two algorithms of O(r + Elogr), one of which is a simple extension of the existing algorithm,
and the other of which is more subtle. The latter is more easily extended to include stochastic
processes of different types.
We apply our faster algorithm to a model of bacteriophage lambda and are able to run the
same calculations on a cluster of desktop workstations that previously required a supercomputer.
This allows us to run more complicated calculations than could be done previously. As an
example of this, we analyse the sensitivity of the lambda model to the values of several of
its parameters. We find that the model is relatively insensitive to changes in the translation
rate, protein dimerization rates and protein degradation rates; is somewhat sensitive to the
transcription rate. and is extremely sensitive to the average number of proteins per mRNA
transcript.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR026A Consistent History Link Connectivity Protocol
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR023
Year: 1998
The RAIN (Reliable Array of Independent Nodes) project at Caltech is focusing on creating
highly reliable distributed systems by leveraging commercially available personal computers.
workstations and interconnect technologies. In particular, the issue of reliable communication
is addressed by introducing redundancy in the form of multiple network interfaces per compute
node.
When using compute nodes with multiple network connections the question of how to
determine connectivity between nodes arises. We examine a connectivity protocol that guarantees
that each side of a point-to-point connection sees the same history of activity over the commu-
nication channel. In other words, we maintain a consistent history of the state of the
communication channel. At any give moment in time the histories as seen by each side are guaranteed
to be identical to within some number of transitions. This bound on how much one side may
lead or lag the other is the slack.
Our main contributions are: (i) a simple, stable protocol for monitoring connectivity that
maintains a consistent history with bounded slack. and (ii) proofs that this protocol exhibits
correctness, bounded slack, and stability.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR023Low Density MDS Codes and Factors of Complete Graphs
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR025
Year: 1998
We reveal an equivalence relation between the construction of a new class of low density
MDS array codes, that we call B-Code, and a combinatorial problem known as perfect one-
factorization of complete graphs. We use known perfect one-factors of complete graphs to
create constructions and decoding algorithms for both B-Code and its dual code. B-Code and
its dual are optimal in the sense that (i) they are MDS, (ii) they have an optimal encoding
property, i.e., the number of the parity bits that are affected by change of a single information
bit is minimal and (iii) they have optimal length. The existence of perfect one-factorizations
for every complete graph with an even number of nodes is a 35 years long conjecture in graph
theory. The construction of B-codes of arbitrary odd length will provide an affirmative answer
to the conjecture.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR025Fault-Tolerant Switched Local Area Networks
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR021
Year: 1998
The RAIN (Reliable Array of Independent Nodes) project at Caltech is focusing on creating highly
reliable distributed systems by leveraging commercially available personal computers, workstations and
interconnect technologies. In particular; the issue of reliable communication is addressed by
introducing redundancy in the form of multiple network interfaces per computer node. When using compute
nodes with multiple network connections
the question of how to best connect these nodes to a given network of switches arises. We examine
networks of
switches (e.g. based on Myrinet technology) and focus on degree two compute nodes (two network adaptor
cards
per node). Our primary goal is to create networks that are as resistant as possible to partitioning.
Our main contributions are: (i) a construction for degree-2 compute nodes connected by a ring network of
switches of degree 4 that can tolerate any 3 switch failures without partitioning the nodes into
disjoint sets, (ii)
a proof that this construction is optimal in the sense that no construction can tolerate more switch
failures while
avoiding partitioning and (iii) generalizations of this construction to arbitrary switch and node
degrees and to
other switch networks, in particular; to a fully-connected network of switches.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR021Improving the Performance of Data Servers Using Array Codes
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR027
Year: 1998
This paper discusses improving performance (throughput) of data server systems by
introducing proper data redundancy into the system. General performance properties of a
server system with redundant data are described. We show that proper data redundancy
in a server system can significantly improve the performance, in addition to the reliability
of the system. Two problems related to the performance together with their solutions
are proposed, namely, the problems of efficient data distribution scheme for the severs
and data acquisition scheme for the client. Both schemes utilize array codes, a class of
error-correcting codes whose encoding and decoding procedures only use simple binary
exclusive-OR operations, which can be implemented efficiently in software and/or hardware.
Construction of general MDS array codes suitable for the both schemes is discussed. A new
property of MDS array codes, called the strong MDS property, is also defined to improve
the data acquisition performance. A method for modeling data server performance and the
related experimental results are presented as well.https://resolver.caltech.edu/CaltechPARADISE:1998.ETR027Trading Weight Size for Circuit Depth: A Circuit for Comparison
https://resolver.caltech.edu/CaltechPARADISE:1998.ETR028
Year: 1998
NOTE: Text or symbols not renderable in plain ASCII are indicated by [...]. Abstract included in .pdf
document.
We present an explicit construction of a circuit for the COMPARISON function in [...],
the class of polynomial-size linear threshold circuits of depth two with polynomially growing
weights. Goldmann and Karpinski proved that [...] in [4]. Hofmeister presented a
simplified version of the same result in [6]. We have further simplified the results of these two
papers by limiting ourselves to the simulation of COMPARISON. Our construction has size
[...], a significant improvement on the general bound of [...] in [6].https://resolver.caltech.edu/CaltechPARADISE:1998.ETR028A Possible Solution to the Impossible Membership Problem
https://resolver.caltech.edu/CaltechPARADISE:1999.ETR032
Year: 1999
This paper presents a solvable specification and gives an algorithm for the Group
Membership Problem in asynchronous systems with crash failures. Our specification
requires processes to maintain a consistent history in their sequence of views. This
allows processes to order failures and recoveries in time and simplifies the programming
of high level applications. Previous work proved that the Group Membership Problem
cannot be solved in asynchronous systems with crash failures. We circumvent this
impossibility result building a weaker, yet non-trivial specification. We show that our
solution is an improvement upon previous attempts to solve this problem using a weaker
specification. We also relate our solution to other methods, and give a classification of
progress properties that can be achieved under different models.https://resolver.caltech.edu/CaltechPARADISE:1999.ETR032Computing in the RAIN: A Reliable Array of Independent Nodes
https://resolver.caltech.edu/CaltechPARADISE:1999.ETR029
Year: 1999
The RAIN project is a research collaboration between Caltech and NASA-JPL on
distributed computing and data storage systems for future spaceborne missions. The goal of the
project is to identify and develop key building blocks for reliable distributed systems built with
inexpensive off-the-shelf components. The RAIN platform consists of a heterogeneous cluster
of computing and/or storage nodes connected via multiple interfaces to networks configured
in fault-tolerant topologies. The RAIN software components run in conjunction with
operating system services and standard network protocols. Through software-implemented fault
tolerance, the system tolerates multiple node, link, and switch failures, with no single point of
failure. The RAIN technology has been transfered to RAINfinity, a start-up company focusing
on creating clustered solutions for improving the performance and availability of Internet data
centers.
In this paper we describe the following contributions: 1) fault-tolerant interconnect topologies and communication protocols providing consistent error reporting of link failures; 2) fault
management techniques based on group membership; and 3) data storage schemes based on
computationally efficient error-control codes. We present several proof-of-concept applications:
highly available video and web servers, and a distributed checkpointing system.https://resolver.caltech.edu/CaltechPARADISE:1999.ETR029Efficient Exact Stochastic Simulation of Chemical Systems with Many Species and Many Channels
https://resolver.caltech.edu/CaltechPARADISE:1999.ETR031
Year: 1999
There are two fundamental ways to view coupled systems of chemical equations: as continuous, represented
by differential equations whose variables are concentrations, or as discrete, represented by stochastic
processes whose variables are numbers of molecules. Although the former is by far more common, systems
with very small numbers of molecules are important in some applications, e.g., in small biological cells
or in surface processes. In both views, most complicated systems with multiple reaction channels and
multiple chemical species cannot be solved analytically. There are exact numerical simulation methods to
simulate trajectories of discrete, stochastic systems, methods that are rigorously equivalent to the
Master Equation approach, but they do not scale well to systems with many reaction pathways.
This paper presents the Next Reaction Method, an exact algorithm to simulate coupled chemical reactions
that is also efficient: it (a) uses only a single random number per simulation event, and (b) takes time
proportional to the logarithm of the number of reactions, not to the number of reactions itself. The
Next Reaction Method is extended to include time-dependent rate constants and non-Markov processes and
it is applied to a sample application in biology: the lysis/lysogeny decision circuit of lambda phage.
When run on lambda the Next Reaction Method requires approximately 1/15th as many operations as a
standard implementation of the existing methods.https://resolver.caltech.edu/CaltechPARADISE:1999.ETR031Splitting the Scheduling Headache
https://resolver.caltech.edu/CaltechPARADISE:1999.ETR030
Year: 1999
The broadcast disk provides an effective way to transmit information from a server to many
clients. Information is broadcast cyclically and clients pick the information they need out of the
broadcast. An example of such a system is a wireless web service where web servers broadcast to
browsing clients. Work has been done to schedule the information broadcast so as to minimize
the expected waiting time of the clients. This work has treated the information as indivisible
blocks that are transmitted in their entirety. We propose a new way to schedule the broadcast of
information, which involves splitting items into smaller sub-items, which need not be broadcast
immediately after each other. This relaxes the previous restrictions, and hence allows us to
have better schedules with lower expected waiting times. We look at the case of two items of
the same length, each split into two halves, and show that we can achieve optimal performance
by choosing the appropriate schedule from a small set of schedules. We derive a set of optimal
schedules and show which one to use, as a function of the demand probabilities. In fact we prove
the surprising result that there are only two possible types of optimal cyclic schedules for items
1 and 2. The first starts with 1122 and the second with 122122. For example, with demand
probabilities p1 = .19 and p2 = 31, the best order to use in broadcasting the halves of items 1
and 2 is a cyclic schedule with cycle 122122.https://resolver.caltech.edu/CaltechPARADISE:1999.ETR030Splitting Schedules for Internet Broadcast Communication
https://resolver.caltech.edu/CaltechPARADISE:2000.ETR034
Year: 2000
The broadcast disk provides an effective way to transmit information from a server to many
clients. Information is broadcast cyclically and clients pick the information they need out of the
broadcast. An example of such a system is a wireless web service where web servers broadcast
to browsing clients. Work has been done to schedule the broadcast of information in a way
that minimizes the expected waiting time of the clients. This work has treated the information
as indivisible blocks. We propose a new way to schedule the broadcast of information, which
involves splitting items into smaller pieces that need not be broadcast consecutively. This relaxes
the previous restrictions, and allows us to have better schedules with lower expected waiting
times. We look at the case of two items of the same length, each split into two halves, and show
that we can achieve optimal performance by choosing the appropriate schedule from a small set
of schedules. We derive a set of optimal schedules and show which one to use, as a function of
the demand probabilities. In fact we prove the surprising result that there are only two possible
types of optimal cyclic schedules for items 1 and 2. These start with 1122 and 122122. For
example, with demand probabilities p subscript1 = .08 and p subscript2 = .92, the best order to use in broadcasting
the halves of items 1 and 2 is a cyclic schedule with cycle 122122222. We also show that much
of the analysis remains the same if we consider items of different lengths. We present numerical
data that suggests that the set of optimal schedules for different length items also consists of
two types, starting with 1122 and 122122. For example, with demand probabilities p subscriptl = .08 and
p subscript2 = .92 as above but lsubscript2 = 2lsubscript1, the best schedule is 11222222.https://resolver.caltech.edu/CaltechPARADISE:2000.ETR034Coding for Tolerance and Detection of Skew in Parallel Asynchronous Communications
https://resolver.caltech.edu/CaltechPARADISE:2000.ETR033
Year: 2000
Abstract to be added.https://resolver.caltech.edu/CaltechPARADISE:2000.ETR033Diversity Coloring for Distributed Storage in Mobile Networks
https://resolver.caltech.edu/CaltechPARADISE:2001.ETR038
Year: 2001
Storing multiple copies of files is crucial for ensuring quality of service for data storage in
mobile networks. This paper proposes a new scheme, called the K-out-of-N file distribution scheme, for
the placement of files. In this scheme files are splitted, and Reed-Solomon codes or other maximum
distance seperable (MDS) codes are used to produce file segments containing parity information. Multiple
copies of the file segments are stored on gateways in the network in such a way that every gateway can
retrieve enough file segments from itself and its neighbors within a certain amount of hops for
reconstructing the orginal files. The goal is to minimize the maximum number of hops it takes for any
gateway to get enough file segments for the file reconstruction.
We formulate the K-out-of-N file distribution scheme as a coloring problem we call diversity coloring.
A diversity coloring is defined to be optimal if it uses the smallest number of colors. Upper and lower
bounds on the performance of diversity coloring for general graphs are studied. Diversity coloring
algorithms for several special classes of graphs - trees, rings and tori - are presented, all of which
have linear time complexity. Both the algorithm for trees and the algorithm for rings output optimal
diversity colorings. The algorithm for tori guarantees to output optimal diversity coloring when the
sizes of tori are sufficiently large.https://resolver.caltech.edu/CaltechPARADISE:2001.ETR038Covering Algorithms, Continuum Percolation, and the Geometry of Wireless Networks.
https://resolver.caltech.edu/CaltechPARADISE:2001.ETR037
Year: 2001
Continuum percolation models where each point of a two-dimensional Poisson
point process is the center of a disc of given (or random) radius r, have been
extensively studied. In this paper, we consider the generalization in which a
deterministic algorithm (given the points of the point process) places the discs
on the plane, in such a way that each disc covers at least one point of the point
process and that each point is covered by at least one disc. This gives a model
for wireless communication networks, which was the original motivation to study
this class of problems.
We look at the percolation properties of this generalized model, showing the
almost sure non-existence of an unbounded connected component of discs for
small values of the density lambda of the Poisson point process, for any covering
algorithm. In general, it turns out not to be true that unbounded connected
components arise when lambda is taken sufficiently high. However, we identify some
large families of covering algorithms, for which such an unbounded component
does arise for large values of lambda.
We show how a simple scaling operation can change the percolation properties
of the model, leading to the almost sure existence of an unbounded connected
component for large values of lambda, for any covering algorithm.
Finally, we show that a large class of covering algorithms, that arise in many
practical applications, can get arbitrarily close to achieving a minimal density of
covering discs. We also show (constructively) the existence of algorithms that
achieve this minimal density.https://resolver.caltech.edu/CaltechPARADISE:2001.ETR037A Geometric Theorem for Approximate Disk Covering Algorithms
https://resolver.caltech.edu/CaltechPARADISE:2001.ETR035
Year: 2001
We present a basic theorem in combinatorial geometry that leads to a family of approximation algorithms for the the geometric disk covering problem. These algorithms exhibit constant approximation factors, with a wide range of their choices. This flexibility allows to achieve a running time that compares favourably with those of existing procedures..https://resolver.caltech.edu/CaltechPARADISE:2001.ETR035Frequency Modulation for Asynchronous Data Transfer
https://resolver.caltech.edu/CaltechPARADISE:2001.ETR036
Year: 2001
Consider a communication channel that consists of several subchannels transmitting simultaneously and
asynchronously. As an example of this scheme, consider a board with two chips (transmitter and receiver). The subchannels represent wires connecting between the chips where differences in the lengths of the wires might result in asynchronous reception. The contribution of this paper is a scheme which allows pipelined asynchronous communication at very high rates even when the amount of skew is arbitrarily large and unknown apriori. Insensitivity to delay is accomplished by encoding data in the frequency of the signal, as opposed to amplitude. The theoretical questions that are answered are what rates can be accomplished. In doing so we have extended the work of Capocelli and Spickerman on generalized Fibonacci numbers. The second question that we answer is
how to encode data efficiently in the frequency of the signal. For the purposes of encoding and decoding
we use variable length to variable length prefix-free codes. We have provided an algorithm based on
integer linear programming for constructing such codes. In essence, we have formulated a scheme which is easy to implement and allows for asynchronous data transfer at very high rates. Potential applications are in on-chip, on-board and board to board communication, enabling much higher bandwidths.https://resolver.caltech.edu/CaltechPARADISE:2001.ETR036Interval Modulation Coding
https://resolver.caltech.edu/CaltechPARADISE:2001.ETR040
Year: 2001
In this paper we introduce a new paradigm for
storage and communication. We call this paradigm Interval
Modulation Coding. Both in the context of
communication and storage, one needs to measure the elapsed time
between voltage transitions or voltage pulses.
Conventionally, this measurement is made by a clock, by counting clock
pulses. Analog circuits (or clocks of higher frequency) can
also be used to measure elapsed time. And in this case the
set of permissible time intervals no longer has to consist of
consecutive integer multiples of the clock period but can be
chosen in accordance with a probabilistic model of
measurement error. We will show that this can potentially provide
substantial improvements in terms of bandwitdth and
storage density over coding techniques deployed in real storage
and communication systems. We provide a mechanism for
encoding and decoding data based on variable length to
variable length prefix free codes. We show that such codes can
be constructed using integer linear programming. From a
theoretical standpoint, we study the linear programming
relaxation of the integer linear program associated with code
construction. We provide an efficient algorithm for
determining if the linear programming relaxation is feasible and
an efficient algorithm for solving the linear programming
relaxation, assuming it is feasible.https://resolver.caltech.edu/CaltechPARADISE:2001.ETR040Microcellular Systems, Random Walks, and Wave Propagation
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR045
Year: 2002
As the number of users of wireless services increases, the concept of using smaller
cell sizes becomes especially attractive because of its potential for capacity increase.
Current technology allows to build base stations for small cells in a cost effective
way, and telecommunication companies have started exploiting the new microcellular
concept in providing coverage to densely populated areas. Prediction of propagation
characteristics in this new scenario is essential for accurate link budget calculations in
network planning.
In this paper a new, simple model of wave propagation for microcellular systems
is applied to predict the path loss of a wireless channel. The model does not rely on
the classical theory of electromagnetic wave propagation, but it is entirely based on
probability theory. We consider the canonical scenario of a random environment of
partially absorbing scatterers and model the trajectory of each photon in the system
as a random walk. This model leads to a path loss formula that rather accurately (in comparison to other models and experimental data) describes the smooth transition
of power attenuation from an inverse square law with the distance to the transmitter
to an exponential attenuation as this distance is increased. This result can justify
empirical formulas that are often used for path loss prediction, characterized by a
breakpoint distance at which the exponent of a power law is increased from a value of
approximately 2 to a value in the range of 4 to 10.
Theoretical predictions of the model are validated by showing agreement with experimental data collected in the city of Rome, Italy.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR045Interleaving Schemes on Circulant Graphs
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR046
Year: 2002
Interleaving schemes are used for error-correcting on a noisy channel. We consider interleaving schemes on infinite circulant graphs with two offsets 1 and d, with a goal to
minimize the interleaving degree. Our constructions are minimal covers of the graph by copies of some subgraph S that can be labeled by a single label. We focus on minimizing the index of S - an inverse of its density rounded up. We establish lower bounds and prove that our constructions are optimal or almost optimal, both for the index of S and for the interleaving degree. We identify related combinatorial questions and advance conjectures.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR046A Geometric Theorem for Wireless Network Design Optimization
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR044
Year: 2002
Consider an infinite square grid G. How many
discs of given radius r, centered at the vertices of G, are
required, in the worst case, to completely cover an arbitrary disc of radius r placed on the plane? We show that this number is an integer in the set (3.4; 5.6) whose value depends on the ratio of r to the grid spacing.
This result can be applied at the very early design stage of
a wireless cellular network to determine, under the recent
International Telecommunication Union (ITU) proposal for
a traffic load model, and under the assumption that each
client is able to communicate if it is within a certain range from a base station, conditions for which a grid network design is cost effective, for any expected traffic demand.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR044Memory Allocation in Information Storage Networks
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR048
Year: 2002
We propose a file storage scheme which bounds the file-retrieving delays in a hetrerogeneous information network, under both fault-free and faulty circumstances. The scheme combines coding with storage for better performance. We study the memory allocation problem for the scheme, which is to decide how much data to store on each node, with the objective of minimizing the total amount of data stored in the network. This problem is NP-hard for general networks. We present three polynomial-time algorithms which solve the memory allocation problem for tree networks. The first two algorithms are for tree networks with and without upper bounds on nodes' memory sizes respectively. The third algorithm finds, among all the optimal solutions for the tree network, the solution that minimizes the greatest memory size of single nodes. By combining these memory allocation algorithms with known data-interleaving techniques, a complete solution to realize the file storage scheme in tree networks is established.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR048Time-Division is Better Than Frequency-Division for Periodic Internet Broadcasting
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR042
Year: 2002
The broadcast disk provides an effective way to transmit information from a server to many
clients. Information is broadcast cyclically and clients pick the information they need out of the
broadcast. An example of such a system is a wireless web service where web servers broadcast
to browsing clients. We consider two ways to send items over a broadcast channel and compare
them using the metric of expected waiting time. The first is frequency-division, where each
item is broadcast on its own subchannel of lower bandwidth. We find the optimal allocation of
bandwidth to the subchannels using this method. Then we look at time-division, where items
are sent sequentially on a single full-bandwidth channel. For items of equal length, we show
that for any frequency-division broadcast schedule, we can find a better time-division schedule.
Thus time-division is better than frequency-division.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR042DNAS: Dispersed Network Attached Storage for Reliability and Performance
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR043
Year: 2002
NOTE: Text or symbols not renderable in plain ASCII are indicated by [...]. Abstract included in .pdf
document.
With the advent of merging between communication and
storage, there is an increasing need for developing dis-
tributed data layout schemes for network attached
storage that address reliability and performance challenges.
This paper proposes a novel scheme for storing
information on networks. In particular, for a fault-free
operation, it provides the ability to retrieve data by accessing
network nodes within a small proximity. In the event of
faults, data is guaranteed to be retrieved by exploring a
slightly larger proximity.
The problem of designing layout schemes, namely pro-
viding Dispersed Network Attached Storage (DNAS), is
formulated as a graph coloring problem that we call
Layered Diversity Coloring. Consider the following problem:
given a graph G(V,E) and N colors, how to color vertices
of G so that every vertex can find at least [...]
In this paper we study the layered diversity coloring
problem where the graph G(V,E) is a tree. A coloring
algorithm of time complexity [...] is
presented, and the sufficient and necessary condition for
there to exist a layered diversity coloring on a tree follows
the algorithm.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR043Ad hoc wireless networks with noisy links
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR047
Year: 2002
Models of ad-hoc wireless networks are often based on the geometric disc abstraction: transmission is assumed to be isotropic, and reliable communication channels are assumed to assumed to exist (apart from interference) between nodes closer than a given distance. In reality communication channels are unreliable and communication range is generally not rotationally symmetric. In this paper we examine how these issues affect network connectivity. Using ideas from percolation theory, we compare networks of geometric discs to other simple shapes, including probabilistic connections, and find that when transmission range and node density are normalized across experiments so as to preserve the expected number of connections (ENC) enjoyed by each node, the discs are the "hardest" shape to connect together. In other words, anisotropic radiation patterns and spotty coverage allow an unbounded connected component to appear at lower ENC levels than perfect circular coverage allows. This indicates that connectivity claims made in the literature using the geometric disc abstraction will in general hold also for the more irregular shapes found in practice.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR047Coding and Scheduling for Efficient Loss-Resilient Data Broadcasting
https://resolver.caltech.edu/CaltechPARADISE:2002.ETR049
Year: 2002
We examine the problem of sending data to clients over a broadcast channel in a way that minimizes the expected waiting time of the clients for this data. This channel, however, is not completely reliable, and packets are occasionally lost. This poses a problem, as performance is greatly degraded by even a single packet loss. For example, one lost packet will increase our expected waiting time for an item from .75 to 2 or 167%, when sending two items with equal demands. We propose and analyze two solutions that attempt to minimize this degradation. In the first, we code packets and in the second we code packets and slightly modify our schedule. The resulting degradations are 67% for the first solution and less than 1% for the second. We conclude that using the second scheme is a very effective way to combat single packet losses, and we extend this solution to combat up to t packet losses per data item for any t [ ] k, where k is the number of packets per data item.https://resolver.caltech.edu/CaltechPARADISE:2002.ETR049Efficient Message Passing Interface (MPI) for Parallel Computing on Clusters of Workstations
https://resolver.caltech.edu/CaltechPARADISE:1994.ETR002
Year: 2002
DOI: 10.1145/215399.215421
Parallel computing on clusters of workstations and personal computers has very high
potential, since it leverages existing hardware and software. Parallel programming
environments offer the user a convenient way to express parallel computation and communication.
In fact, recently, a Message Passing Interface (MPI) has been proposed as an industrial
standard for writing "portable" message-passing parallel programs. The communication
part of MPI consists of the usual point-to-point communication as well as collective
communication. However, existing implementations of programming environments for clusters
are built on top of a point-to-point communication layer (send and receive) over local
area networks (LANs) and, as a result, suffer from poor performance in the collective
communication part.
In this paper, we present an efficient design and implementation of the collective
communication part in MPI that is optimized for clusters of workstations. Our system consists
of two main components: the MPI-CCL layer that includes the collective communication
functionality of MPI and a User-level Reliable Transport Protocol (URTP) that interfaces
with the LAN Data-link layer and leverages the fact that the LAN is a broadcast medium.
Our system is integrated with the operating system via an efficient kernel extension
mechanism that we developed. The kernel extension significantly improves the performance of
our implementation as it can handle part of the communication overhead without involving
user space.
We have implemented our system on a collection of IBM RS/6000 workstations con-
nected via a lOMbit Ethernet LAN. Our performance measurements are taken from typical
scientific programs that run in a parallel mode by means of the MPI. The hypothesis behind
our design is that system's performance will be bounded by interactions between the kernel
and user space rather than by the bandwidth delivered by the LAN Data-Link Layer. Our
results indicate that the performance of our MPI Broadcast (on top of Ethernet) is about
twice as fast as a recently published software implementation of broadcast on top of ATM.https://resolver.caltech.edu/CaltechPARADISE:1994.ETR002Interleaving Schemes on Circulant Graphs with Two Offsets
https://resolver.caltech.edu/CaltechPARADISE:2003.ETR054
Year: 2003
To be added.https://resolver.caltech.edu/CaltechPARADISE:2003.ETR054Multi-Cluster interleaving in linear arrays and rings
https://resolver.caltech.edu/CaltechPARADISE:2003.ETR051
Year: 2003
Interleaving codewords is an important method not only for combatting burst-errors, but also for flexible data-retrieving. This paper defines the Multi-Cluster Interleaving (MCI) problem, an interleaving problem for parallel data-retrieving. The MCI problems on linear arrays and rings are studied. The following problem is completely solved: how to interleave integers on a linear array or ring such that any m (m greater than or equal to 2) non-overlapping segments of length 2 in the array or ring have at least 3 distinct integers. We then present a scheme using a 'hierarchical-chain structure' to solve the following more general problem for linear arrays: how to interleave integers on a linear array such that any m (m greater than or equal to 2) non-overlapping segments of length L (L greater than or equal to 2) in the array have at least L + 1 distinct integers. It is shown that the scheme using the 'hierarchical-chain structure' solves the second interleaving problem for arrays that are asymptotically as long as the longest array on which an MCI exists, and clearly, for shorter arrays as well.https://resolver.caltech.edu/CaltechPARADISE:2003.ETR051Algorithmic Aspects of Cyclic Combinational Circuit Synthesis
https://resolver.caltech.edu/CaltechPARADISE:ETR053
Year: 2003
Digital circuits are called combinational if they are memoryless: if they have outputs that depend only on the current values of the inputs. Combinational circuits are generally thought of as acyclic (i.e., feed-forward) structures. And yet, cyclic circuits can be combinational. Cycles sometimes occur in designs synthesized from high-level descriptions, as well as in bus-based designs [16]. Feedback in such cases is carefully contrived, typically occurring when functional units are connected in a cyclic topology. Although the premise of cycles in combinational circuits has been accepted, and analysis techniques have been proposed [7], no one has attempted the synthesis of circuits with feedback at the logic level.
We have argued the case for a paradigm shift in combinational circuit design [10]. We should no longer think of combinational logic as acyclic in theory or in practice, since most combinational circuits are best designed with cycles. We have proposed a general methodology for the synthesis of multilevel networks with cyclic topologies and incorporated it in a general logic synthesis environment. In trials, benchmark circuits were optimized significantly, with improvements of up to 30%I n the area. In this paper, we discuss algorithmic aspects of cyclic circuit design. We formulate a symbolic framework for analysis based on a divide-and-conquer strategy. Unlike previous approaches, our method does not require ternary-valued simulation. Our analysis for combinationality is tightly coupled with the synthesis phase, in which we assemble a combinational network from smaller combinational components. We discuss the underpinnings of the heuristic search methods and present examples as well as synthesis results for benchmark circuits.
In this paper, we discuss algorithmic aspects of cyclic circuit design. We formulate a symbolic framework for analysis based on a divide-and-conquer strategy. Unlike previous approaches, our method does not require ternary-valued simulation. Our analysis for combinationality is tightly coupled with the synthesis phase, in which we assemble a combinational network from smaller combinational components. We discuss the underpinnings of the heuristic search methods and present examples as well as synthesis results for benchmark circuits.https://resolver.caltech.edu/CaltechPARADISE:ETR053The Synthesis of Cyclic Combinatorial Circuits
https://resolver.caltech.edu/CaltechPARADISE:ETR052a
Year: 2003
To be added.https://resolver.caltech.edu/CaltechPARADISE:ETR052aThe Synthesis of Cyclic Combinatorial Circuits
https://resolver.caltech.edu/CaltechPARADISE:ETR052
Year: 2003
To be added.https://resolver.caltech.edu/CaltechPARADISE:ETR052Percolation in Multi-hop Wireless Networks
https://resolver.caltech.edu/CaltechPARADISE:2003.ETR055
Year: 2003
To be addedhttps://resolver.caltech.edu/CaltechPARADISE:2003.ETR055Optimal Interleaving on Tori
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR059
Year: 2004
We study t-interleaving on two-dimensional tori, which is defined by the property that any connected subgraph with t or fewer vertices in the torus is labelled by all distinct integers. It has applications in distributed data storage and burst error correction, and is closely related to Lee metric codes. We say that a torus can be perfectly t-interleaved if its t-interleaving number – the minimum number of distinct integers needed to t-interleave the torus – meets the spherepacking lower bound. We prove the necessary and sufficient conditions for tori that can be perfectly t-interleaved, and present efficient perfect t-interleaving constructions. The most important contribution of this paper is to prove that the t-interleaving numbers of tori large enough in both dimensions, which constitute by far the majority of all existing cases, is at most one more than
the sphere-packing lower bound, and to present an optimal and efficient t-interleaving scheme for them. Then we prove some bounds on the t-interleaving numbers for other cases, completing a general picture for the t-interleaving problem on 2-dimensional tori.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR059Scheduling for Efficient Data Broadcast over Two Channels
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR056
Year: 2004
The broadcast disk provides a way to distribute data to many clients simultaneously. A central server fixes a set of data and a schedule for sending it, and then repeatedly sends the data according to the schedule. Clients listen for data until it is broadcast. We look at the problem of scheduling for two separate channels, where each can have a different broadcast schedule. Our metric for measuring schedule performance is expected delivery time (EDT), the expected value of the total elapsed time between when a client starts listening for data and when the client is completely finished receiving the data. We fix the first channel with a schedule that is optimal for an average case, and look at how to schedule for the second channel.We show two interesting results for sending two items over two channels. The first is that all schedules with equal portions of the two items in the second channel have the same EDT. The second is that for a situation that is symmetric in the two items the optimal schedule is asymmetric with respect to these items.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR056Optimal Unviersal Schedules for Discrete Broadcast
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR057
Year: 2004
In this paper we study the scenario in which a server sends dynamic data over a single broadcast channel to
a number of passive clients. We consider the data to consist of discrete packets, where each update is sent in a
separate packet. On demand, each client listens to the channel in order to obtain the most recent data packet. Such
scenarios arise in many practical applications such as the distribution of weather and traffic updates to wireless
mobile devices and broadcasting stock price information over the Internet.
To satisfy a request, a client must listen to at least one packet from beginning to end. We thus consider the design
of a broadcast schedule which minimizes the time that passes between a clients request and the time that it hears a
new data packet, i.e., the waiting time of the client. Previous studies have addressed this objective, assuming that
client requests are distributed uniformly over time. However, in the general setting, the clients behavior is difficult
to predict and might not be known to the server. In this work we consider the design of universal schedules that
guarantee a short waiting time for any possible client behavior. We define the model of dynamic broadcasting in
the universal setting, and prove various results regarding the waiting time achievable in this framework.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR057Timing Analysis of Cyclic Combinatorial Circuits
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR060.1160
Year: 2004
The accepted wisdom is that combinational circuits must have acyclic (i.e., loop-free or feed-forward) topologies. And yet simple examples suggest that this need not be so. In previous work, we advocated the design of cyclic combinational circuits (i.e., circuits with loops or feedback paths). We proposed a methodology for analyzing and synthesizing such circuits, with an emphasis on the optimization of area.
In this paper, we extend our methodology into the temporal realm. We characterize the true delay of cyclic circuits through symbolic event propagation in the floating mode of operation, according to the up-bounded inertial delay model. We present analysis results for circuits optimized with our program CYCLIFY. Some benchmark circuits were optimized significantly, with simultaneous improvements of up to 10% in the area and 25% in the delay.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR060.1160A Combinatorial Bound on the List Size
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR058
Year: 2004
In this paper we study the scenario in which a server sends dynamic data over a single broadcast channel to
a number of passive clients. We consider the data to consist of discrete packets, where each update is sent in a
separate packet. On demand, each client listens to the channel in order to obtain the most recent data packet. Such
scenarios arise in many practical applications such as the distribution of weather and traffic updates to wireless
mobile devices and broadcasting stock price information over the Internet.
To satisfy a request, a client must listen to at least one packet from beginning to end. We thus consider the design
of a broadcast schedule which minimizes the time that passes between a clients request and the time that it hears a new data packet, i.e., the waiting time of the client. Previous studies have addressed this objective, assuming that client requests are distributed uniformly over time. However, in the general setting, the clients behavior is difficult to predict and might not be known to the server. In this work we consider the design of universal schedules that guarantee a short waiting time for any possible client behavior. We define the model of dynamic broadcasting in
the universal setting, and prove various results regarding the waiting time achievable in this framework.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR058Network File Storage With Graceful Performance Degradation
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR061
Year: 2004
A file storage scheme is proposed for networks containing heterogeneous clients. In the scheme, the
performance measured by file-retrieval delays degrades gracefully under increasingly serious faulty
circumstances. The scheme combines coding with storage for better performance. The problem
is NP-hard for general networks; and this paper focuses on tree networks with asymmetric edges
between adjacent nodes. A polynomial-time memory-allocation algorithm is presented, which
determines how much data to store on each node, with the objective of minimizing the total
amount of data stored in the network. Then a polynomial-time data-interleaving algorithm is used
to determine which data to store on each node for satisfying the quality-of-service requirements in
the scheme. By combining the memory-allocation algorithm with the data-interleaving algorithm,
an optimal solution to realize the file storage scheme in tree networks is established.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR061Optimal Schedules for Asynchronous Transmission of Discrete Packets
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR062
Year: 2004
In this paper we study the distribution of dynamic data over a broadcast channel to a large number of
passive clients. Clients obtain the information by accessing the channel and listening for the next available
packet. This scenario, referred to as packet-based or discrete broadcast, has many practical applications such
as the distribution of weather and traffic updates to wireless mobile devices, reconfiguration and reprogramming
of wireless sensors and downloading dynamic task information in battlefield networks.
The optimal broadcast protocols require a high degree of synchronization between the server and the
wireless clients. However, in typical wireless settings such degree of synchronization is difficult to achieve
due to the inaccuracy of internal clocks. Moreover, in some settings, such as military applications, synchronized
transmission is not desirable due to jamming. The lack of synchronization leads to large delays
and excessive power consumption. Accordingly, in this work we focus on the design of optimal broadcast
schedules that are robust to clock inaccuracy. We present universal schedules for delivery of up-to-date
information with minimum waiting time in asynchronous settings.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR062The Encoding Complexity of Network Coding
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR063
Year: 2004
In the multicast network coding problem, a source s needs to deliver h packets to a set of k terminals over an underlying network G. The nodes of the coding network can be broadly categorized into two groups. The first group includes encoding nodes, i.e., nodes that generate new packets by combining data received from two or more incoming links. The second group includes forwarding nodes that can only duplicate and forward the incoming packets. Encoding nodes are, in general, more expensive due to the need to equip them with encoding capabilities. In addition, encoding nodes incur delay and increase the overall complexity of the network.
Accordingly, in this paper we study the design of multicast coding networks with a limited number of encoding nodes. We prove that in an acyclic coding network, the number of encoding nodes required to achieve the capacity of the network is bounded by h^3k^2. Namely, we present (efficiently constructible) network codes that achieve
capacity in which the total number of encoding nodes is independent of the size of the network and is bounded by h^3k^2. We show that the number of encoding nodes may depend both on h and k as we present acyclic instances of the multicast network coding problem in which [Omega](h^2k) encoding nodes are needed.
In the general case of coding networks with cycles, we show that the number of encoding nodes is limited by the size of the feedback link set, i.e., the minimum number of links that must be removed from the network in order to eliminate cycles. Specifically, we prove that the number of encoding nodes is bounded by (2B+1)h^3k^2, where B is the minimum size of the feedback link set. Finally, we observe that determining or even crudely approximating the minimum number of encoding nodes needed to achieve the capacity for a given instance of the network coding problem is NP-hard.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR063Monotone Percolation and The Topology Control of Wireless Networks
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR065
Year: 2005
This paper addresses the topology control problem for large wireless networks that are modelled by an infinite point process on a two-dimensional plane. Topology control is the process of determining the edges in the network by adjusting
the transmission radii of the nodes. Topology control algorithms should be based on local decisions, be adaptive to changes, guarantee full connectivity and support efficient routing. We present a family of topology control algorithms that, respectively, achieve some or all of these requirements efficiently. The key idea in our algorithms is a concept that we call monotone percolation. In classical percolation theory, we are interested in the emergence of an infinitely large connected component. In contrast, in monotone percolation we are interested in the existence of a relatively short path that makes monotonic progress between any pair of source and destination nodes. Our key contribution is that we demonstrate how local decisions on the transmission radii can lead to monotone percolation and in turn to efficient topology control algorithms.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR065Network Coding for Nonuniform Demands
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR064
Year: 2005
In this paper we define nonuniform-demand networks as a useful connection model, in between multicasts and general connections. In these networks, the source has a pool of messages, and each sink demands a certain number of messages, without specifying their identities. We study the solvability of such networks and give a tight bound on the number of sinks that achieve capacity in a worst-case network. We propose constructions to solve networks at, or slightly below capacity, and investigate the effect large alphabets have on the solvability of such networks. We also show that our efficient constructions are suboptimal when used in networks with more sinks, yet this comes with little surprise considering the fact that the general problem is shown to be NP-hard.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR064An automated system for measuring parameters of nematode sinusoidal movement
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR066
Year: 2005
Background: Nematode sinusoidal movement has been used as a phenotype in many studies of C. elegans development, behavior and physiology. A thorough understanding of the ways in which genes control these aspects of biology depends, in part, on the accuracy of phenotypic analysis. While worms that move poorly are relatively easy to describe, description of hyperactive movement and movement modulation presents more of a challenge. An enhanced capability to analyze all the complexities of nematode movement will thus help our understanding of how genes control behavior.
Results: We have developed a user-friendly system to analyze nematode movement in an automated and quantitative manner. In this system nematodes are automatically recognized and a computer-controlled microscope stage ensures that the nematode is kept within the camera field of view while video images from the camera are stored on videotape. In a second step, the images from the videotapes are processed to recognize the worm and to extract its changing position and posture over time. From this information, a variety of movement parameters are calculated. These parameters include the velocity of the worm's centroid, the velocity of the worm along its track, the extent and frequency of body bending, the amplitude and wavelength of the sinusoidal movement, and the propagation of the contraction wave along the body. The length of the worm is also determined and used to normalize the amplitude and wavelength measurements.
To demonstrate the utility of this system, we report here a comparison of movement parameters for a small set of mutants
affecting the Go/Gq mediated signaling network that controls acetylcholine release at the neuromuscular junction. The system allows comparison of distinct genotypes that affect movement similarly (activation of Gq-alpha versus loss of Go-alpha function), as well as of different mutant alleles at a single locus (null and dominant negative alleles of the goa-1 gene, which encodes Goalpha). We also demonstrate the use of this system for analyzing the effects of toxic agents. Concentration-response curves for the toxicants arsenite and aldicarb, both of which affect motility, were determined for wild-type and several mutant strains,
identifying P-glycoprotein mutants as not significantly more sensitive to either compound, while cat-4 mutants are more sensitive to arsenite but not aldicarb.
Conclusions: Automated analysis of nematode movement facilitates a broad spectrum of experiments. Detailed genetic analysis of multiple alleles and of distinct genes in a regulatory network is now possible. These studies will facilitate quantitative modeling of C. elegans movement, as well as a comparison of gene function. Concentration-response curves will allow rigorous analysis
of toxic agents as well as of pharmacological agents. This type of system thus represents a powerful analytical tool that can be readily coupled with the molecular genetics of nematodes.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR066Implementability Among Predicates
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR067
Year: 2005
Much work has been done to understand when given predicates (relations) on discrete variables can be conjoined to implement other predicates. Indeed, the lattice of "co-clones" (sets of predicates closed under conjunction, variable renaming, and existential quantification of variables) has been investigated steadily from the 1960's to the present. Here, we investigate a more general model, where duplicatability of values is not taken for granted. This model is motivated in part by large scale neural models, where duplicating a value is similar in cost to computing a function, and by quantum mechanics, where values cannot be duplicated. Implementations in this case are naturally given by a graph fragment in which vertices are predicates, internal edges are existentially quantified variables, and "dangling edges" (edges emanating from a vertex but not yet connected to another vertex) are the free variables of the implemented predicate. We examine questions of implementability among predicates in this scenario, and
we present the solution to all implementability problems for single predicates on up to three boolean values. However, we find that a variety of proof methods are required, and the question of implementability indeed becomes undecidable for larger predicates, although this is tricky to prove. We find that most predicates cannot implement the 3-way equality predicate, which reaffirms the view that duplicatability of values should not be assumed a priori.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR067Localization and Routing in Sensor Networks by Local Angle
Information
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR068
Year: 2005
DOI: 10.1145/1062689.1062713
Location information is very useful in the design of sensor network infrastructures. In this paper, we study the anchor-free 2D localization problem by using local angle measurements in a sensor network. We prove that given a unit disk graph and the angles between adjacent edges, it is NP-hard to find a valid embedding in the plane such that neighboring nodes are within distance 1 from each other and non-neighboring nodes are at least distance 1 away. Despite the negative results, however, one can find a planar spanner
of a unit disk graph by using only local angles. The planar spanner can be used to generate a set of virtual coordinates that enable efficient and local routing schemes such as geographical routing or approximate shortest path routing. We also proposed a practical anchor-free embedding scheme by solving a linear program. We show by simulation that not only does it give very good local embedding, i.e., neighboring nodes are close and non-neighboring nodes are far away, but it also gives a quite accurate global view
such that geographical routing and approximate shortest path routing on the embedded graph are almost identical to those on the original (true) embedding. The embedding algorithm can be adapted to other models of wireless sensor networks and is robust to measurement noise.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR068MAP: Medial Axis Based Geometric Routing in Sensor Networks
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR069
Year: 2005
DOI: 10.1145/1080829.1080839
One of the challenging tasks in the deployment of dense wireless networks (like sensor networks) is in devising a routing scheme for node to node communication. Important consideration includes scalability, routing complexity, the length of the communication paths and the load sharing of the routes. In this paper, we show that a compact and expressive abstraction of network connectivity by the medial axis enables efficient and localized routing. We propose MAP, a Medial Axis based naming and routing Protocol that does not require locations, makes routing decisions locally, and achieves good load balancing. In its preprocessing phase, MAP constructs the medial axis of the sensor field, defined as the set of nodes with at least two closest boundary nodes. The medial axis of the network captures both the complex geometry and non-trivial topology of the sensor field. It can be represented compactly by a graph whose size is comparable with the complexity of the geometric features (e.g., the number of holes). Each node is then given a name related to its position with respect to the medial axis. The routing scheme is derived through local decisions based on the names of the source and destination nodes and guarantees delivery with reasonable and natural routes. We show by both theoretical analysis and simulations that our medial axis based geometric routing scheme is scalable, produces short routes, achieves excellent load balancing, and is very robust to variations in the network model.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR069Anti-Jamming Schedules for Wireless Broadcast Systems
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR070
Year: 2005
Modern society is heavily dependent on wireless networks for providing voice and data communications. Wireless data broadcast has recently emerged as an attractive way to disseminate data to a large number of clients. In data broadcast systems, the server proactively transmits the information on a downlink channel; the clients access the data by listening to the channel. Wireless data broadcast systems can serve a large number of heterogeneous clients, minimizing power consumption as well as protecting the privacy of the clients' locations.
The availability and relatively low cost of antennas resulted in a number of potential threats to the integrity of the wireless infrastructure. The existing solutions and schedules for wireless data broadcast are vulnerable to jamming, i.e., the use of active signals to prevent data distribution. The goal of jammers is to disrupt the normal operation of the broadcast system, which results in high waiting time and excessive power consumption for the clients.
In this paper we investigate efficient schedules for wireless data broadcast that perform well in the presence of a jammer. We show that the waiting time of client can be efficiently reduced by adding redundancy to the schedule. The main challenge in the design of redundant broadcast schedules is to ensure that the transmitted information is always up-to-date. Accordingly, we present schedules that guarantee low waiting time and low staleness of data in the presence of a jammer. We prove that our schedules are optimal if the jamming signal has certain energy limitations.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR070Networks of Relations for Representation, Learning, and Generalization
https://resolver.caltech.edu/CaltechPARADISE:2005.ETR071
Year: 2005
We propose representing knowledge as a network of relations. Each relation relates only a few continuous or discrete variables, so that any overall relationship among the many variables treated by the network winds up being distributed throughout the network. Each relation encodes which combinations of values correspond to past experience for the variables related by the relation. Variables may or may not correspond to understandable aspects of the situation being modeled by the network. A distributed calculational process can be used to access the information stored in such a network, allowing the network to function as an associative memory. This process in its simplest form is purely inhibitory, narrowing down the space of possibilities as much as possible given the data to be matched. In contrast with methods that always retrieve a best fit for all variables, this method can return values for inferred variables while leaving non-inferable variables in an unknown or partially known state. In contrast with belief propagation methods, this method can be proven to converge quickly and uniformly for any network topology, allowing networks to be as interconnected as the relationships warrant, with no independence assumptions required. The generalization properties of such a memory are aligned with the network's relational representation of how the various aspects of the modeled situation are related.https://resolver.caltech.edu/CaltechPARADISE:2005.ETR071Adaptive Bloom filter
https://resolver.caltech.edu/CaltechPARADISE:2006.ETR072
Year: 2006
A Bloom filter is a simple randomized data structure that answers membership query with no false negative and a small false positive probability. It is an elegant data compression technique for membership information, and has broad applications. In this paper, we generalize the traditional Bloom filter to Adaptive Bloom Filter, which incorporates the information on the query frequencies and the membership likelihood of the elements into its optimal design. It has been widely observed that in many applications, some popular elements are queried much more often than the others. The traditional Bloom filter for data sets with irregular query patterns and non-uniform membership likelihood can be further optimized. We derive the optimal configuration of the Bloom filter with query-frequency and membership-likelihood information, and show that the adapted Bloom filter always outperforms the traditional Bloom filter. Under reasonable frequency models such as the step distribution or the Zipf's distribution, the improvement of the false positive probability of the adaptive Bloom filter over that of the traditional Bloom filter is usually of orders of magnitude.https://resolver.caltech.edu/CaltechPARADISE:2006.ETR072On the Capacity of Precision-Resolution Constrained Systems
https://resolver.caltech.edu/CaltechPARADISE:2006.ETR073
Year: 2006
Arguably, the most famous constrained system is the (d, k)-RLL (Run-Length Limited), in which a stream of bits obeys the constraint that every two 1's are separated by at least d 0's, and there are no more than k consecutive 0's anywhere in the stream. The motivation for this scheme comes from the fact that certain sensor characteristics restrict the minimum time between adjacent 1's or else the two will be merged in the receiver, while a clock drift between transmitter and receiver may cause spurious 0's or missing 0's at the receiver if too many appear consecutively.
The interval-modulation scheme introduced by Mukhtar and Bruck extends the RLL constraint and implicitly suggests a way of taking advantage of higher-precision clocks. Their work however, deals only with an encoder/decoder construction.
In this work we introduce a more general framework which we call the precision-resolution (PR) constrained system. In PR systems, the encoder has precision constraints, while the decoder has resolution constraints. We examine the capacity of PR systems and show the gain in the presence of a high-precision encoder (thus, we place the PR system with integral encoder, (p=1,alpha,theta)-PR, which turns out to be a simple extension of RLL, and the PR system with infinite-precision encoder, (infinity,alpha,theta)-PR, on two ends of a continuum). We derive an exact expression for their capacity in terms of the precision p, the minimal resolvable measurement at the decoder alpha, and the decoder resolution factor theta. In an analogy to the RLL terminology these are the clock precision, the minimal time between peaks, and the clock drift. Surprisingly, even with an infinite-precision encoder, the capacity is finite.https://resolver.caltech.edu/CaltechPARADISE:2006.ETR073Network Coding: A Computational Perspective
https://resolver.caltech.edu/CaltechPARADISE:2006.ETR074
Year: 2006
In this work, we study the computational perspective of network coding, focusing on two issues. First, we address the computational complexity of finding a network code for acyclic multicast networks. Second, we address the issue of reducing the amount of computation performed by network nodes. In particular, we consider the problem of finding a network code with the minimum possible number of encoding nodes, i.e., nodes that generate new packets by combining the packets received over incoming links.
We present a deterministic algorithm that finds a feasible network code for a multicast network over an underlying graph G(V,E) in time O(|E|kh + |V |k2h2 + h4k3(k + h)), where k is the number of destinations and h is the number of packets. Our result improves the best known running time of O(|E|kh+ |V |k2h2(k + h)) of the algorithm due to Jaggi et al. [1] in the typical case of large communication graphs. In addition, our algorithm guarantees that the number of encoding nodes in the obtained network code is bounded by O(h3k2).
Next, we address the problem of finding a network code with the minimum number of encoding nodes in both integer and fractional coding networks. We prove that in the majority of settings this problem is NP-hard. However, we show that if h = O(1), k = O(1), and the underlying communication graph is acyclic, then there exists an algorithm that solves this problem in polynomial time.https://resolver.caltech.edu/CaltechPARADISE:2006.ETR074Shortening Array Codes and the Perfect 1-Factorization Conjecture
https://resolver.caltech.edu/CaltechPARADISE:2006.ETR075
Year: 2006
The existence of a perfect 1-factorization of the complete graph Kn, for arbitrary n, is a 40-year old open problem in graph theory. Two infinite families of perfect 1-factorizations are known for K2p and Kp+1, where p is a prime. It was shown in [8] that finding a perfect 1-factorization of Kn can be reduced to a problem in coding, i.e. to constructing an MDS, lowest density array code of length n. In this paper, a new method for shortening arbitrary array codes is introduced. It is then used to derive the Kp+1 family of perfect 1-factorizations from the K2p family, by applying the reduction metioned above. Namely, techniques from coding theory are used to prove a new result in graph theory.https://resolver.caltech.edu/CaltechPARADISE:2006.ETR075Cyclic Low-Density MDS Array Codes
https://resolver.caltech.edu/CaltechPARADISE:2006.ETR076
Year: 2006
We construct two infinite families of low density MDS array codes which are also cyclic. One of these families includes the first such sub-family with redundancy parameter r > 2. The two constructions have different algebraic formulations, though they both have the same indirect structure. First MDS codes that are not cyclic are constructed and then by applying a certain mapping to their parity check matrices, non-equivalent cyclic codes with the same distance and density properties are obtained. Using the same proof techniques, a third infinite family of quasi-cyclic codes can be constructed.https://resolver.caltech.edu/CaltechPARADISE:2006.ETR076Exact Stochastic Simulation of Chemical Reactions with Cycle Leaping
https://resolver.caltech.edu/CaltechPARADISE:2006.ETR077
Year: 2006
The stochastic simulation algorithm (SSA), first proposed by Gillespie, has become the workhorse of computational biology. It tracks integer quantities of the molecular species, executing reactions at random based on propensity calculations. An estimate for the resulting quantities of the different species is obtained by averaging the results of repeated trials. Unfortunately, for models with many reaction channels and many species, the algorithm requires a prohibitive amount of computation time. Many trials must be performed, each forming a lengthy trajectory through the state space. With coupled or reversible reactions, the simulation often loops through the same sequence of states repeatedly, consuming computing time, but making no forward progress.
We propose a algorithm that reduces the simulation time through cycle leaping: when cycles are encountered, the exit probabilities are calculated. Then, in a single bound, the simulation leaps directly to one of the exit states. The technique is exact, sampling the state space with the expected probability distribution. It is a component of a general framework that we have developed for stochastic simulation based on probabilistic analysis and caching.https://resolver.caltech.edu/CaltechPARADISE:2006.ETR077Increasing the Information Density of Storage Systems Using the Precision-Resolution Paradigm
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR078
Year: 2007
Arguably, the most prominent constrained system in storage applications is the (d, k)-RLL (Run-Length Limited) system, where every binary sequence obeys the constraint that every two adjacent 1's are separated by at least d consecutive 0's and at most k consecutive 0's, namely, runs of 0's are length limited. The motivation for the RLL constraint arises mainly from the physical limitations of the read and write technologies in magnetic and optical storage systems.
We revisit the rationale for the RLL system and reevaluate its relationship to the physical media. As a result, we introduce a new paradigm that better matches the physical constraints. We call the new paradigm the Precision-Resolution (PR) system, where the write operation is limited by precision and the read operation is limited by resolution.
We compute the capacity of a general PR system and demonstrate that it provides a significant increase in the information density compared to the traditional RLL system (for identical physical limitations). For example, the capacity of the (2, 10)-RLL used in CD-ROMs and DVDs is approximately 0.5418, while our PR system provides the capacity of about 0.7725, resulting in a potential increase of about 40% in information density.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR078Codes for Multi-Level Flash Memories: Correcting Asymmetric Limited-Magnitude Errors
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR079
Year: 2007
Several physical effects that limit the reliability and performance of Multilevel Flash memories induce errors that have low magnitude and are dominantly asymmetric. This paper studies block codes for asymmetric limited-magnitude errors over q-ary channels. We propose code constructions for such channels when the number of errors is bounded by t. The construction uses known codes for symmetric errors over small alphabets to protect large-alphabet symbols from asymmetric limited-magnitude errors. The encoding and decoding of these codes are performed over the small alphabet whose size depends only on the maximum error magnitude and is independent of the alphabet size of the outer code. An extension of the construction is proposed to include systematic codes as a benet to practical implementation.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR079Synthesizing Stochasticity in Biochemical Systems
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR081
Year: 2007
Randomness is inherent to biochemistry: at each instant, the sequence of reactions that fires is a matter of chance. Some biological systems exploit such randomness, choosing between different outcomes stochastically – in effect, hedging their bets with a portfolio of responses for different environmental conditions. In this paper, we discuss techniques for synthesizing such stochastic behavior in engineered biochemical systems. We propose a general method for designing a set of biochemical reactions that produces different combinations of molecular types according to a specified probability distribution. The response is precise and robust to perturbations. Furthermore, it is programmable: the probability distribution is a function of the quantities of input types. The method is modular and extensible. We discuss strategies for implementing various functional dependencies: linear, logarithmic, exponential, etc. This work has potential applications in domains such as biochemical sensing, drug production, and disease treatment. Moreover, it provides a framework for analyzing and characterizing the stochastic dynamics in natural biochemical systems such as the lysis/lysogeny switch of the lambda bacteriophage.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR081Constrained Codes as Networks of Relations
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR082
Year: 2007
We revisit the well-known problem of determining the capacity of constrained systems. While the one-dimensional case is well understood, the capacity of two-dimensional systems is mostly unknown. When it is non-zero, except for the (1,1)-RLL system on the hexagonal lattice, there are no closed-form analytical solutions known. Furthermore, for the related problem of counting the exact number of constrained arrays of any given size, only exponential-time algorithms are known.
We present a novel approach to finding the exact capacity
of two-dimensional constrained systems, as well as efficiently counting the exact number of constrained arrays of any given size. To that end, we borrow graph-theoretic tools originally developed for the field of statistical mechanics, tools for efficiently simulating quantum circuits, as well as tools from the theory of the spectral distribution of Toeplitz matrices.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR082Floating Codes for Joint Information Storage in Write Asymmetric Memories
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR080
Year: 2007
Memories whose storage cells transit irreversibly between states have been common since the start of the data storage technology. In recent years, flash memories and other non-volatile memories based on floating-gate cells have become a very important family of such memories. We model them by the Write Asymmetric Memory (WAM), a memory where each cell is in one of q states – state 0, 1, ... , q-1 – and can only transit from a lower state to a higher state. Data stored in a WAM can be rewritten by shifting the cells to higher states. Since the state transition is irreversible, the number of times of rewriting is limited. When multiple variables are stored in a WAM, we study codes, which we call floating codes, that maximize the total number of times the variables can be written and rewritten.
In this paper, we present several families of floating codes
that either are optimal, or approach optimality as the codes get longer. We also present bounds to the performance of general floating codes. The results show that floating codes can integrate the rewriting capabilities of different variables to a surprisingly high degree.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR080Buffer Coding for Asymmetric Multi-Level Memory
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR083
Year: 2007
Certain storage media such as flash memories use write-asymmetric, multi-level storage elements. In such media, data is stored in a multi-level memory cell the contents of which can only be increased, or reset. The reset operation is expensive and should be delayed as much as possible. Mathematically, we consider the problem of writing a binary sequence into write-asymmetric q-ary cells, while recording the last r bits written. We want to maximize t, the number of possible writes, before a reset is needed. We introduce the term Buffer Code, to describe the solution to this problem. A buffer code is a code that remembers the r most recent values of a variable. We present the construction of a single-cell (n = 1) buffer code that can store a binary (l = 2) variable with t = [q/2^(r - 1)] + r - 2 and a universal upper bound to the number of rewrites that a single-cell buffer code can have: ..... We also show a binary buffer code with arbitrary n, q, r, namely, the code uses n q-ary cells to remember the r most recent values of one binary variable. The code can rewrite the variable times, which is asymptotically optimal in q and n. . We then extend the code construction for the case r = 2, and obtain a code that can rewrite the variable t = (q - 1)(n - 2) + 1 times. When q = 2, the code is strictly optimal.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR083Distributed Broadcasting and Mapping Protocols in Directed Anonymous Networks
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR084
Year: 2007
We initiate the study of distributed protocols over directed anonymous networks that are not necessarily strongly connected. In such networks, nodes are aware only of their incoming and outgoing edges, have no unique identity, and have no knowledge of the network topology or even bounds on its parameters, like the number of nodes or the network diameter. Anonymous networks are of interest in various settings such as wireless ad-hoc networks and peer to peer networks. Our goal is to create distributed protocols that reduce the uncertainty by distributing the knowledge of the network topology to all the nodes.
We consider two basic protocols: broadcasting and unique label assignment. These two protocols enable a complete mapping of the network and can serve as key building blocks in more advanced protocols. We develop distributed asynchronous protocols as well as derive lower bounds on their communication complexity, total bandwidth complexity, and node label complexity. The resulting lower bounds are sometimes surprisingly high, exhibiting the complexity of topology extraction in directed anonymous networks.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR084Computation with Finite Stochastic Chemical Reaction Networks
https://resolver.caltech.edu/CaltechPARADISE:2007.ETR085
Year: 2007
A highly desired part of the synthetic biology toolbox is an embedded chemical microcontroller, capable of autonomously following a logic program specified by a set of instructions, and interacting with its cellular environment. Strategies for incorporating logic in aqueous chemistry have focused primarily on implementing components, such as logic gates, that are composed into larger circuits, with each logic gate in the circuit corresponding to one or more molecular species. With this paradigm, designing and producing new molecular species is necessary to perform larger computations. An alternative approach begins by noticing that chemical systems on the small scale are fundamentally discrete and stochastic. In particular, the exact molecular counts of each molecular species present, is an intrinsically available form of information. This might appear to be a very weak form of information, perhaps quite difficult for computations to utilize. Indeed, it has been shown that error-free Turing universal computation is impossible in this setting. Nevertheless, we show a design of a chemical computer that achieves fast and reliable Turing-universal computation using molecular counts. Our scheme uses only a small number of different molecular species to do computation of arbitrary complexity. The total probability of error of the computation can be made arbitrarily small (but not zero) by adjusting the initial molecular counts of certain species. While physical implementations would be difficult, these results demonstrate that molecular counts can be a useful form of information for small molecular systems such as those operating within cellular environments.https://resolver.caltech.edu/CaltechPARADISE:2007.ETR085Rank Modulation for Flash Memories
https://resolver.caltech.edu/CaltechPARADISE:2008.ETR086
Year: 2008
We explore a novel data representation scheme for multi-level flash memory cells, in which a set of n cells stores information in the permutation induced by the different charge levels of the individual cells. The only allowed charge-placement mechanism is a "push-to-the-top" operation which takes a single cell of the set and makes it the top-charged cell. The resulting scheme eliminates the need for discrete cell levels, as well as overshoot errors, when programming cells.
We present unrestricted Gray codes spanning all possible n-cell states and using only "push-to-the-top" operations, and also construct balanced Gray codes. We also investigate optimal rewriting schemes for translating arbitrary input alphabet into n-cell states which minimize the number of programming operations.https://resolver.caltech.edu/CaltechPARADISE:2008.ETR086Joint Coding for Flash Memory Storage
https://resolver.caltech.edu/CaltechPARADISE:2008.ETR087
Year: 2008
Flash memory is an electronic non-volatile memory with wide applications. Due to the substantial impact of block erasure operations on the speed, reliability and longevity of flash memories, writing schemes that enable data to be modified numerous times without incurring the block erasure is desirable. This requirement is addressed by floating codes, a coding scheme that jointly stores and rewrites data and maximizes the rewriting capability of flash memories. In this paper, we present several new floating code constructions. They include both codes with specific parameters and general code constructions that are asymptotically optimal. We also present bounds to the performance of floating codes.https://resolver.caltech.edu/CaltechPARADISE:2008.ETR087Codes for Asymmetric Limited-Magnitude Errors with Application to Multi-Level Flash Memories
https://resolver.caltech.edu/CaltechPARADISE:2008.ETR088
Year: 2008
Several physical effects that limit the reliability and
performance of Multilevel Flash Memories induce errors that
have low magnitudes and are dominantly asymmetric. This paper studies block codes for asymmetric limited-magnitude errors over q-ary channels. We propose code constructions and bounds for such channels when the number of errors is bounded by t and the error magnitudes are bounded by ࡁ. The constructions utilize known codes for symmetric errors, over small alphabets, to protect large-alphabet symbols from asymmetric limited-magnitude errors. The encoding and decoding of these codes are performed over the small alphabet whose size depends only on the maximum error magnitude and is independent of the alphabet size of the outer code. Moreover, the size of the codes is shown
to exceed the sizes of known codes (for related error models), and asymptotic rate-optimality results are proved. Extensions of the construction are proposed to accommodate variations on the error model and to include systematic codes as a benefit to practical implementation.https://resolver.caltech.edu/CaltechPARADISE:2008.ETR088Programmability of Chemical Reaction Networks
https://resolver.caltech.edu/CaltechPARADISE:2008.ETR090
Year: 2008
Motivated by the intriguing complexity of biochemical circuitry within individual cells we study Stochastic Chemical Reaction Networks (SCRNs), a formal model that considers a set of chemical reactions acting on a finite number of molecules in a well-stirred solution according to standard chemical kinetics equations. SCRNs have been widely used for describing naturally occurring (bio)chemical systems, and with the advent of synthetic biology they become a promising language for the design of artificial biochemical circuits. Our interest here is the computational power of SCRNs and how they relate to more conventional models of computation. We survey known connections and give new connections between SCRNs and Boolean Logic Circuits, Vector Addition Systems, Petri Nets, Gate Implementability, Primitive Recursive Functions, Register Machines, Fractran, and Turing Machines. A theme to these investigations is the thin line between decidable and undecidable questions about SCRN behavior.https://resolver.caltech.edu/CaltechPARADISE:2008.ETR090On the capacity of bounded rank modulation for flash memories
https://resolver.caltech.edu/CaltechPARADISE:2008.ETR091
Year: 2009
Rank modulation has been recently introduced as a new information representation scheme for flash memories.
Given the charge levels of a group of flash cells, sorting
is used to induce a permutation, which in turn represents
data. Motivated by the lower sorting complexity of smaller
cell groups, we consider bounded rank modulation, where
a sequence of permutations of given sizes are used to
represent data. We study the capacity of bounded rank
modulation under the condition that permutations can
overlap for higher capacity.https://resolver.caltech.edu/CaltechPARADISE:2008.ETR091The Robustness of Stochastic Switching Networks
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR092
Year: 2009
Many natural systems, including chemical and biological systems, can be modeled using stochastic switching circuits. These circuits consist of stochastic switches, called pswitches, which operate with a fixed probability of being open or closed. We study the effect caused by introducing an error of size ∈ to each pswitch in a stochastic circuit. We analyze two constructions – simple series-parallel and general series-parallel circuits – and prove that simple series-parallel circuits are robust to small error perturbations, while general series-parallel circuits are not. Specifically, the total error introduced by perturbations of size less than ∈ is bounded by a constant multiple of ∈ in a simple series-parallel circuit, independent of the size of the circuit. However, the same result does not hold in the case of more general series-parallel circuits. In the case of a general stochastic circuit, we prove that the overall error probability is bounded by a linear function of the number of pswitches.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR092On the Expressibility of Stochastic Switching Circuits
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR093
Year: 2009
Stochastic switching circuits are relay circuits that consist of stochastic switches (that we call pswitches). We study the expressive power of these circuits; in particular, we address the following basic question: given an arbitrary integer q, and a pswitch set {1/q, 2/q, ..., (q–1)/q }, can we realize any rational probability with denominator q n (for arbitrary n) by a simple series-parallel stochastic switching circuit? In this paper, we generalized previous results and prove that when q is a multiple of 2 or 3 the answer is positive. We also show that when q is a prime number the answer is negative. In addition, we propose a greedy algorithm to realize desired reachable probabilities, and thousands of experiments show that this algorithm can achieve almost optimal size. Finally, we prove that any desired probability can be approximated well by a linear size circuit.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR093Universal Rewriting in Constrained Memories
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR096
Year: 2009
A constrained memory is a storage device whose elements change their states under some constraints. A typical example is flash memories, in which cell levels are easy to increase but hard to decrease. In a general rewriting model, the stored data changes with some pattern determined by the application. In a constrained memory, an appropriate representation is needed for the stored data to enable efficient rewriting.
In this paper, we define the general rewriting problem using a graph model. This model generalizes many known rewriting models such as floating codes, WOM codes, buffer codes, etc. We present a novel rewriting scheme for the flash-memory model and prove it is asymptotically optimal in a wide range of scenarios.
We further study randomization and probability distributions to data rewriting and study the expected performance. We present a randomized code for all rewriting sequences and a deterministic code for rewriting following any i.i.d. distribution. Both codes are shown to be optimal asymptotically.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR096Correcting Charge-Constrained Errors in the Rank-Modulation Scheme
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR095
Year: 2009
We investigate error-correcting codes for a novel storage technology for flash memories, the rank-modulation scheme. In this scheme, a set of n cells stores information in the permutation induced by the different charge levels of the individual cells. The resulting scheme eliminates the need for discrete cell levels, overcomes overshoot errors when programming cells (a serious problem that reduces the writing speed), and mitigates the problem of asymmetric errors.
In this paper we study the properties of error-correcting codes for charge-constrained errors in the rank-modulation scheme. In this error model the number of errors corresponds to the minimal number of adjacent transpositions required to change a given stored permutation to another erroneous one – a distance measure known as Kendall's τ-distance.
We show bounds on the size of such codes, and use metric-embedding techniques to give constructions which translate a
wealth of knowledge of binary codes in the Hamming metric as well as q-ary codes in the Lee metric, to codes over permutations in Kendall's τ-metric. Specifically, the one-error-correcting codes we construct are at least half the ball-packing upper bound.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR095Stochastic Switching Circuit Synthesis
https://resolver.caltech.edu/CaltechPARADISE:2008.ETR089
Year: 2009
In his 1938 Master's Thesis, Shannon demonstrated that any Boolean function can be realized by a switching relay circuit, leading to the development of deterministic digital logic. Here, we replace each classical switch with a probabilistic switch (pswitch). We present algorithms for synthesizing circuits closed with a desired probability, including an algorithm that generates optimal size circuits for any binary fraction. We also introduce a new duality property for series-parallel stochastic switching circuits. Finally, we construct a universal probability generator which maps deterministic inputs to arbitrary probabilistic outputs. Potential applications exist in the analysis and design of stochastic networks in biology and engineering.https://resolver.caltech.edu/CaltechPARADISE:2008.ETR089Data Movement in Flash Memories
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR097
Year: 2009
NAND flash memories are the most widely used non-volatile memories, and data movement is common in flash storage
systems. We study data movement solutions that minimize the number of block erasures, which are very important for the
efficiency and longevity of flash memories. To move data among n blocks with the help of Δ auxiliary blocks, where every block
contains m pages, we present algorithms that use θ(n • min{m, log_Δ n}) erasures without the tool of coding. We prove this is
almost the best possible for non-coding solutions by presenting a nearly matching lower bound. Optimal data movement can be
achieved using coding, where only θ(n) erasures are needed. We present a coding-based algorithm, which has very low coding
complexity, for optimal data movement. We further show the NP hardness of both coding-based and non-coding schemes when
the objective is to optimize data movement on a per instance basis.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR097Storage Coding for Wear Leveling in Flash Memories
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR094
Year: 2009
NAND flash memories are currently the most widely
used type of flash memories. In a NAND flash memory, although a
cell block consists of many pages, to rewrite one page, the whole
block needs to be erased and reprogrammed. Block erasures
determine the longevity and efficiency of flash memories. So when
data is frequently reorganized, which can be characterized as a
data movement process, how to minimize block erasures becomes
an important challenge. In this paper, we show that coding
can significantly reduce block erasures for data movement, and
present several optimal or nearly optimal algorithms. While the
sorting-based non-coding schemes require O(n log n) erasures to
move data among n blocks, coding-based schemes use only O(n)
erasures and also optimize the utilization of storage space.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR094Low-Complexity Codes for Random and Clustered High-Order Failures in Storage Arrays
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR098
Year: 2009
RC (Random/Clustered) codes are a new efficient array-code family for recovering from 4-erasures. RC codes correct most 4-erasures, and essentially all 4-erasures that are clustered. Clustered erasures are introduced as a new erasure model for storage arrays. This model draws its motivation from correlated device failures, that are caused by physical proximity of devices, or by age proximity of endurance-limited solid-state drives. The reliability of storage arrays that employ RC codes is analyzed and compared to known codes. The new RC code is significantly more efficient, in all practical implementation factors, than the best known 4-erasure correcting MDS code. These factors include: small-write update-complexity, full-device update-complexity, decoding complexity and number of supported devices in the array.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR098Cyclic Boolean circuits
https://resolver.caltech.edu/CaltechPARADISE:2009.ETR099
Year: 2009
A Boolean circuit is a collection of gates and wires that performs a mapping from Boolean inputs to Boolean outputs. The accepted wisdom is that such circuits must have acyclic (i.e., loop-free or feed-forward) topologies. In fact, the model is often defined this way – as a directed acyclic graph (DAG). And yet simple examples suggest that this is incorrect. We advocate that Boolean circuits should have cyclic topologies (i.e., loops or feedback paths). In other work, we demonstrated the practical implications of this view: digital circuits can be designed with fewer gates if they contain cycles. In this paper, we explore the theoretical underpinnings of the idea. We show that the complexity of implementing Boolean functions can be lower with cyclic topologies than with acyclic topologies. With examples, we show that certain Boolean functions can be implemented by cyclic circuits with as little as one-half the number gates that are required by equivalent acyclic circuits.https://resolver.caltech.edu/CaltechPARADISE:2009.ETR099Data Movement and Aggregation in Flash Memories
https://resolver.caltech.edu/CaltechPARADISE:2010.ETR100
Year: 2010
NAND flash memories have become the most widely used type of non-volatile memories. In a NAND flash memory, every block of memory cells consists of numerous pages, and rewriting a single page requires the whole block to be erased. As block erasures significantly reduce the longevity, speed and power efficiency of flash memories, it is critical to minimize the number of erasures when data are reorganized. This leads to the data movement problem, where data need to be switched in blocks, and the objective is to minimize the number of block erasures. It has been shown that optimal solutions can be obtained by coding. However, coding-based algorithms with the minimum coding complexity still remain an important topic to study.
In this paper, we present a very efficient data movement algorithm with coding over GF(2) and with the minimum storage requirement. We also study data movement with more auxiliary blocks and present its corresponding solution. Furthermore, we extend the study to the data aggregation problem, where data can not only be moved but also aggregated. We present both non-coding and coding-based solutions, and rigorously prove the performance gain by using coding.https://resolver.caltech.edu/CaltechPARADISE:2010.ETR100On the Synthesis of Stochastic Flow Networks
https://resolver.caltech.edu/CaltechPARADISE:2010.ETR101
Year: 2010
DOI: 10.48550/arXiv.1209.0724
A stochastic flow network is a directed graph with incoming edges (inputs) and outgoing edges (outputs), tokens enter through the input edges, travel stochastically in the network and can exit the network through the output edges. Each node in the network is a splitter, namely, a token can enter a node through an incoming edge and exit on one of the output edges according to a predefined probability distribution. We address the following synthesis question: Given a finite set of possible splitters and an arbitrary rational probability distribution, design a stochastic flow network, such that every token that enters the input edge will exit the outputs with the prescribed probability distribution.
The problem of probability synthesis dates back to von Neummann's 1951 work and was followed, among others, by Knuth and Yao in 1976, who demonstrated that arbitrary rational probabilities can be generated with tree networks; where minimizing the expected path length, the expected number of coin tosses in their paradigm, is the key consideration. Motivated by the synthesis of stochastic DNA based molecular systems, we focus on designing optimal size stochastic flow networks (the size of a network is the number of splitters). We assume that each splitter has two outgoing edges and is unbiased (probability 1/2 per output edge). We show that an arbitrary rational probability a/b with a ≤ b ≤ 2^n can be realized by a stochastic flow network of size n, we also show that this is optimal. We note that our stochastic flow networks have feedback (cycles in the network), in fact, we demonstrate that feedback improves the expressibility of stochastic flow networks, since without feedback only probabilities of the form a/2^n (a an integer) can be realized.https://resolver.caltech.edu/CaltechPARADISE:2010.ETR101Efficiently Generating Random Bits from Finite State Markov Chains
https://resolver.caltech.edu/CaltechPARADISE:2010.ETR102
Year: 2010
The problem of random number generation from an uncorrelated random source (of unknown probability distribution) dates back to von Neumann's 1951 work. Elias (1972) generalized von Neumann's scheme and showed how to achieve optimal efficiency in unbiased random bits generation. Hence, a natural question is what if the sources are correlated? Both Elias and Samuelson proposed methods for generating unbiased random bits in the case of correlated sources (of unknown probability distribution), specifically, they considered finite Markov chains. However, their proposed methods are not efficient or have implementation difficulties. Blum (1986) devised an algorithm for efficiently generating random bits from degree-2 finite Markov chains in expected linear time, however, his beautiful method is still far from optimality on information-efficiency. In this paper, we generalize Blum's algorithm to arbitrary degree finite Markov chains and combine it with Elias's method for efficient generation of unbiased bits. As a result, we provide the first known algorithm that generates unbiased random bits from an arbitrary finite Markov chain, operates in expected linear time and achieves the information-theoretic upper bound on efficiency.https://resolver.caltech.edu/CaltechPARADISE:2010.ETR102Rebuilding for Array Codes in Distributed Storage Systems
https://resolver.caltech.edu/CaltechPARADISE:2010.ETR103
Year: 2010
In distributed storage systems that use coding, the issue of minimizing the communication required to rebuild a storage node after a failure arises. We consider the problem of repairing an erased node in a distributed storage system that uses an EVENODD code. EVENODD codes are maximum distance separable (MDS) array codes that are used to protect against erasures, and only require XOR operations for encoding and decoding. We show that when there are two redundancy nodes, to rebuild one erased systematic node, only 3=4 of the information needs to be transmitted. Interestingly, in many cases, the required disk I/O is also minimized.https://resolver.caltech.edu/CaltechPARADISE:2010.ETR103Constant-Weight Gray Codes for Local Rank Modulation
https://resolver.caltech.edu/CaltechPARADISE:2010.ETR105
Year: 2010
We consider the local rank-modulation scheme in which a sliding window going over a sequence of real-valued variables induces a sequence of permutations. Local rank- modulation is a generalization of the rank-modulation scheme, which has been recently suggested as a way of storing information in flash memory.
We study constant-weight Gray codes for the local rank- modulation scheme in order to simulate conventional multi-level flash cells while retaining the benefits of rank modulation. We provide necessary conditions for the existence of cyclic and cyclic optimal Gray codes. We then specifically study codes of weight 2 and upper bound their efficiency, thus proving that there are no such asymptotically-optimal cyclic codes. In contrast, we study codes of weight 3 and efficiently construct codes which are asymptotically-optimal. We conclude with a construction of codes with asymptotically-optimal rate and weight asymptotically half the length, thus having an asymptotically-optimal charge difference between adjacent cells.https://resolver.caltech.edu/CaltechPARADISE:2010.ETR105Trajectory Codes for Flash Memory
https://resolver.caltech.edu/CaltechPARADISE:2010.ETR104
Year: 2011
DOI: 10.48550/arXiv.1012.5430
Flash memory is well-known for its inherent asymmetry: the flash-cell charge levels are easy to increase but are hard to decrease. In a general rewriting model, the stored data changes its value with certain patterns. The patterns of data updates are determined by the data structure and the application, and are independent of the constraints imposed by the storage medium. Thus, an appropriate coding scheme is needed so that the data changes can be updated and stored efficiently under the storage-medium's constraints.
In this paper, we define the general rewriting problem using a graph model. It extends many known rewriting models such as floating codes, WOM codes, buffer codes, etc. We present a new rewriting scheme for flash memories, called the trajectory code, for rewriting the stored data as many times as possible without block erasures. We prove that the trajectory code is asymptotically optimal in a wide range of scenarios.
We also present randomized rewriting codes optimized for expected performance (given arbitrary rewriting sequences). Our rewriting codes are shown to be asymptotically optimal.https://resolver.caltech.edu/CaltechPARADISE:2010.ETR104Generating Probability Distributions using Multivalued Stochastic Relay Circuits
https://resolver.caltech.edu/CaltechPARADISE:2011.ETR106
Year: 2011
DOI: 10.48550/arXiv.1102.1441
The problem of random number generation dates
back to von Neumann's work in 1951. Since then, many algorithms
have been developed for generating unbiased bits from
complex correlated sources as well as for generating arbitrary
distributions from unbiased bits. An equally interesting, but less
studied aspect is the structural component of random number
generation as opposed to the algorithmic aspect. That is, given
a network structure imposed by nature or physical devices,
how can we build networks that generate arbitrary probability
distributions in an optimal way?
In this paper, we study the generation of arbitrary probability
distributions in multivalued relay circuits, a generalization in
which relays can take on any of N states and the logical
'and' and 'or' are replaced with 'min' and 'max' respectively.
Previous work was done on two-state relays. We generalize these
results, describing a duality property and networks that generate
arbitrary rational probability distributions. We prove that these
networks are robust to errors and design a universal probability
generator which takes input bits and outputs arbitrary binary
probability distributions.https://resolver.caltech.edu/CaltechPARADISE:2011.ETR106Generalized Gray Codes for Local Rank Modulation
https://resolver.caltech.edu/CaltechPARADISE:2011.ETR107
Year: 2011
DOI: 10.48550/arXiv.1103.0317
We consider the local rank-modulation scheme in
which a sliding window going over a sequence of real-valued
variables induces a sequence of permutations. Local rank-modulation
is a generalization of the rank-modulation scheme,
which has been recently suggested as a way of storing information
in flash memory.
We study Gray codes for the local rank-modulation scheme
in order to simulate conventional multi-level flash cells while
retaining the benefits of rank modulation. Unlike the limited
scope of previous works, we consider code constructions for the
entire range of parameters including the code length, sliding
window size, and overlap between adjacent windows. We show
our constructed codes have asymptotically-optimal rate. We also
provide efficient encoding, decoding, and next-state algorithms.https://resolver.caltech.edu/CaltechPARADISE:2011.ETR107Compressed Encoding for Rank Modulation
https://resolver.caltech.edu/CaltechPARADISE:2011.ETR108
Year: 2011
DOI: 10.48550/arXiv.1108.2741
Rank modulation has been recently proposed as
a scheme for storing information in flash memories. While
rank modulation has advantages in improving write speed and
endurance, the current encoding approach is based on the "push
to the top" operation that is not efficient in the general case. We
propose a new encoding procedure where a cell level is raised to
be higher than the minimal necessary subset -instead of all - of
the other cell levels. This new procedure leads to a significantly
more compressed (lower charge levels) encoding. We derive an
upper bound for a family of codes that utilize the proposed
encoding procedure, and consider code constructions that achieve
that bound for several special cases.https://resolver.caltech.edu/CaltechPARADISE:2011.ETR108MDS Array Codes with Optimal Rebuilding
https://resolver.caltech.edu/CaltechPARADISE:2011.ETR110
Year: 2011
DOI: 10.48550/arXiv.1103.3737
MDS array codes are widely used in storage systems
to protect data against erasures. We address the rebuilding ratio
problem, namely, in the case of erasures, what is the the fraction
of the remaining information that needs to be accessed in order
to rebuild exactly the lost information? It is clear that when the
number of erasures equals the maximum number of erasures
that an MDS code can correct then the rebuilding ratio is 1
(access all the remaining information). However, the interesting
(and more practical) case is when the number of erasures is
smaller than the erasure correcting capability of the code. For
example, consider an MDS code that can correct two erasures:
What is the smallest amount of information that one needs to
access in order to correct a single erasure? Previous work showed
that the rebuilding ratio is bounded between 1/2 and 3/4 , however,
the exact value was left as an open problem. In this paper, we
solve this open problem and prove that for the case of a single
erasure with a 2-erasure correcting code, the rebuilding ratio is
1/2 . In general, we construct a new family of r-erasure correcting
MDS array codes that has optimal rebuilding ratio of 1/r
in the
case of a single erasure. Our array codes have efficient encoding
and decoding algorithms (for the case r = 2 they use a finite field
of size 3) and an optimal update property.https://resolver.caltech.edu/CaltechPARADISE:2011.ETR110On Codes for Optimal Rebuilding Access
https://resolver.caltech.edu/CaltechPARADISE:2011.ETR111
Year: 2011
DOI: 10.48550/arXiv.1107.1627
MDS (maximum distance separable) array codes
are widely used in storage systems due to their computationally
efficient encoding and decoding procedures. An MDS code with
r redundancy nodes can correct any r erasures by accessing
(reading) all the remaining information in both the systematic
nodes and the parity (redundancy) nodes. However, in practice,
a single erasure is the most likely failure event; hence, a natural
question is how much information do we need to access in order
to rebuild a single storage node? We define the rebuilding ratio
as the fraction of remaining information accessed during the
rebuilding of a single erasure. In our previous work we showed
that the optimal rebuilding ratio of 1/r is achievable (using
our newly constructed array codes) for the rebuilding of any
systematic node, however, all the information needs to be accessed
for the rebuilding of the parity nodes. Namely, constructing array
codes with a rebuilding ratio of 1/r was left as an open problem.
In this paper, we solve this open problem and present array codes
that achieve the lower bound of 1/r for rebuilding any single
systematic or parity node.https://resolver.caltech.edu/CaltechPARADISE:2011.ETR111Systematic Error-Correcting Codes for Rank Modulation
https://resolver.caltech.edu/CaltechPARADISE:2011.ETR112
Year: 2011
DOI: 10.48550/arXiv.1310.6817
The rank modulation scheme has been proposed recently for efficiently writing and storing data in nonvolatile
memories. Error-correcting codes are very important for rank
modulation; however, existing results have bee limited.
In this work, we explore a new approach, systematic error-correcting codes for rank modulation. Systematic codes have the benefits of enabling efficient information retrieval and potentially supporting more efficient encoding and decoding procedures. We study systematic codes for rank modulation equipped with the Kendall's τ-distance. We present (k + 2, k) systematic codes for correcting one error, which have optimal rates unless perfect
codes exist. We also study the design of multi-error-correcting codes, and prove that for any 2 ≤ k < n, there always exists an (n,k) systematic code of minimum distance
n − k. Furthermore, we prove that for rank modulation, systematic codes achieve the same capacity as general error-correcting codes.https://resolver.caltech.edu/CaltechPARADISE:2011.ETR112Variable-level Cells for Nonvolatile Memories
https://resolver.caltech.edu/CaltechAUTHORS:20120502-125850834
Year: 2012
For many nonvolatile memories, – including flash
memories, phase-change memories, etc., – maximizing the storage
capacity is a key challenge. The existing method is to use multilevel cells (MLC) of more and more levels. The number of levels
supported by MLC is seriously constrained by the worst-case
performance of cell-programming noise and cell heterogeneity.
In this paper, we present variable-level cells (VLC), a new
scheme for maximum storage capacity. It adaptively chooses the
number of levels and the placement of the levels based on the
actual programming performance. We derive its storage capacity,
and present an optimal data representation scheme. We also study
rewriting schemes for VLC, and present inner and outer bounds
to its capacity region.https://resolver.caltech.edu/CaltechAUTHORS:20120502-125850834Patterned Cells for Phase Change Memories
https://resolver.caltech.edu/CaltechAUTHORS:20120502-130441311
Year: 2012
Phase-change memory (PCM) is an emerging nonvolatile memory technology that promises very high performance.
It currently uses discrete cell levels to represent data, controlled
by a single amorphous/crystalline domain in a cell. To improve
data density, more levels per cell are needed. There exist a number of challenges, including cell programming noise, drifting of
cell levels, and the high power requirement for cell programming.
In this paper, we present a new cell structure called patterned cell, and explore its data representation schemes. Multiple
domains per cell are used, and their connectivity is used to
store data. We analyze its storage capacity, and study its error-correction capability and the construction of error-control codes.https://resolver.caltech.edu/CaltechAUTHORS:20120502-130441311Trade-offs between Instantaneous and Total Capacity in Multi-Cell Flash Memories
https://resolver.caltech.edu/CaltechAUTHORS:20120516-141137208
Year: 2012
The limited endurance of flash memories is a major
design concern for enterprise storage systems. We propose a
method to increase it by using relative (as opposed to fixed)
cell levels and by representing the information with Write
Asymmetric Memory (WAM) codes. Overall, our new method
enables faster writes, improved reliability as well as improved
endurance by allowing multiple writes between block erasures.
We study the capacity of the new WAM codes with relative levels,
where the information is represented by multiset permutations
induced by the charge levels, and show that it achieves the
capacity of any other WAM codes with the same number of
writes. Specifically, we prove that it has the potential to double
the total capacity of the memory. Since capacity can be achieved
only with cells that have a large number of levels, we propose a
new architecture that consists of multi-cells - each an aggregation
of a number of floating gate transistors.https://resolver.caltech.edu/CaltechAUTHORS:20120516-141137208Long MDS Codes for Optimal Repair Bandwidth
https://resolver.caltech.edu/CaltechAUTHORS:20120616-221646611
Year: 2012
MDS codes are erasure-correcting codes that can
correct the maximum number of erasures given the number of
redundancy or parity symbols. If an MDS code has r parities
and no more than r erasures occur, then by transmitting all
the remaining data in the code one can recover the original
information. However, it was shown that in order to recover a
single symbol erasure, only a fraction of 1/r of the information
needs to be transmitted. This fraction is called the repair
bandwidth (fraction). Explicit code constructions were given in
previous works. If we view each symbol in the code as a vector
or a column, then the code forms a 2D array and such codes
are especially widely used in storage systems. In this paper, we
ask the following question: given the length of the column l, can
we construct high-rate MDS array codes with optimal repair
bandwidth of 1/r, whose code length is as long as possible? In
this paper, we give code constructions such that the code length
is (r + 1)log_r l.https://resolver.caltech.edu/CaltechAUTHORS:20120616-221646611Sequence Reconstruction for Grassmann Graphs and Permutations
https://resolver.caltech.edu/CaltechAUTHORS:20130215-095250632
Year: 2013
The sequence-reconstruction problem was first proposed
by Levenshtein in 2001. This problem studies the model
where the same word is transmitted over multiple channels. If
the transmitted word belongs to some code of minimum distance
d and there are at most r errors in every channel, then the minimum
number of channels that guarantees a successful decoder
(under the assumption that all channel outputs are distinct) has
to be greater than the largest intersection of two balls of radius
r and with distance at least d between their centers.
This paper studies the combinatorial problem of computing
the largest intersection of two balls for two cases. In the first
part we solve this problem in the Grassmann graph for all values
of d and r. In the second part we derive similar results for
permutations under Kendall's t-metric for some special cases of
d and r.https://resolver.caltech.edu/CaltechAUTHORS:20130215-095250632Codes for Network Switches
https://resolver.caltech.edu/CaltechAUTHORS:20130128-153803180
Year: 2013
A network switch routes data packets between its
multiple input and output ports. Packets from input ports are
stored upon arrival in a switch fabric comprising multiple
memory banks. This can result in memory contention when
distinct output ports request packets from the same memory
bank, resulting in a degraded switching bandwidth. To solve this
problem, we propose to add redundant memory banks for storing
the incoming packets. The problem we address is how to minimize
the number of redundant memory banks given some guaranteed
contention resolution capability. We present constructions of
new switch memory architectures based on different coding
techniques. The codes allow decreasing the redundancy by 1/2
or 2/3, depending on the request specifications, compared to
non-coding solutions.https://resolver.caltech.edu/CaltechAUTHORS:20130128-153803180Rank-Modulation Rewriting Codes for Flash Memories
https://resolver.caltech.edu/CaltechAUTHORS:20130128-144020108
Year: 2013
Current flash memory technology is focused on
cost minimization of the stored capacity. However, the resulting
approach supports a relatively small number of write-erase
cycles. This technology is effective for consumer devices (smartphones
and cameras) where the number of write-erase cycles is
small, however, it is not economical for enterprise storage systems
that require a large number of lifetime writes.
Our proposed approach for alleviating this problem consists of
the efficient integration of two key ideas: (i) improving reliability
and endurance by representing the information using relative
values via the rank modulation scheme and (ii) increasing the
overall (lifetime) capacity of the flash device via rewriting codes,
namely, performing multiple writes per cell before erasure.
We propose a new scheme that combines rank-modulation
with rewriting. The key benefits of the new scheme include: (i)
the ability to store close to 2 bits per cell on each write, and
rewrite the memory close to q times, where q is the number
of levels in each cell, and (ii) efficient encoding and decoding
algorithms that use the recently proposed polar WOM codes.https://resolver.caltech.edu/CaltechAUTHORS:20130128-144020108Building Consensus via Iterative Voting
https://resolver.caltech.edu/CaltechAUTHORS:20130215-093909657
Year: 2013
In networked systems comprised of many agents, it is often required to reach a common operating point of all agents, termed the network consensus. We consider two iterative methods for reaching a ranking (ordering) consensus over a voter network, where the initial preference of every voter is of the form of a full ordering of candidates. The voters are allowed, one at a time and based on some random scheme, to change their vote to bring them "closer" to the opinions of selected subsets of peers. The first consensus method is based on changing votes one adjacent swap at a time; the second method is based on changing a vote via averaging with the
votes of peers, potentially leading to many adjacent swaps at a time vote. For the first model, we characterize convergence points and conditions for convergence. For the second model, we prove convergence to a global ranking and derive the rate of convergence to this consensus.https://resolver.caltech.edu/CaltechAUTHORS:20130215-093909657In-Memory Computing of Akers Logic Array
https://resolver.caltech.edu/CaltechAUTHORS:20130215-092157295
Year: 2013
This work studies memories from a different perspective,
while the goal is to explore the concept of in-memory
computing. Our point of departure is an old study of logic arrays
by Akers in 1972. We demonstrate how these arrays can
simultaneously store information and perform logic operations.
We first extend the structure of these arrays for non-binary
alphabets. We then show how a special structure of these arrays
can both store elements and output a sorted version of them. We
also study other examples of the in-memory computing concept.
In this setup, it is shown how information can be stored and
computed with, and the array can tolerate or detect errors in
the stored data.https://resolver.caltech.edu/CaltechAUTHORS:20130215-092157295Error-Correcting Codes for Multipermutations
https://resolver.caltech.edu/CaltechAUTHORS:20130215-094523026
Year: 2013
THIS PAPER IS ELIGIBLE FOR THE STUDENT
PAPER AWARD. Multipermutations appear in various applications
in information theory. New applications such as rank
modulation for flash memories and voting have suggested the need
to consider error-correcting codes for multipermutations. The construction
of codes is challenging when permutations are considered
and it becomes even a harder problem for multipermutations. In
this paper we discuss the general problem of error-correcting codes
for multipermutations. We present some tight bounds on the size of
error-correcting codes for several families of multipermutations.
We find the capacity of the channels of multipermutations and
characterize families of perfect codes in this metric which we
believe are the only such perfect codes.https://resolver.caltech.edu/CaltechAUTHORS:20130215-094523026Information-Theoretic Study of Voting Systems
https://resolver.caltech.edu/CaltechAUTHORS:20130215-092855327
Year: 2013
The typical paradigm in voting theory involves n
voters and m candidates. Every voter ranks the candidates resulting
in a permutation of the m candidates. A key problem is
to derive the aggregate result of the voting. A popular method
for vote aggregation is based on the Condorcet criterion. The
Condorcet winner is the candidate who wins every other candidate
by pairwise majority. However, the main disadvantage of
this approach, known as the Condorcet paradox, is that such a
winner does not necessarily exist since this criterion does not admit
transitivity. This paradox is mathematically likely (if voters
assign rankings uniformly at random, then with probability approaching
one with the number of candidates, there will not be
a Condorcet winner), however, in real life scenarios such as elections,
it is not likely to encounter the Condorcet paradox. In this
paper we attempt to improve our intuition regarding the gap between
the mathematics and reality of voting systems. We study a
special case where there is global intransitivity between all candidates.
We introduce tools from information theory and derive
an entropy-based characterization of global intransitivity. In addition,
we tighten this characterization by assuming that votes
tend to be similar; in particular they can be modeled as permutations
that are confined to a sphere defined by the Kendalls τ
distance.https://resolver.caltech.edu/CaltechAUTHORS:20130215-092855327The Capacity of String-Replication Systems
https://resolver.caltech.edu/CaltechAUTHORS:20140127-105959677
Year: 2014
DOI: 10.48550/arXiv.1401.4634
It is known that the majority of the human genome
consists of repeated sequences. Furthermore, it is believed that a significant part of the rest of the genome also originated from repeated sequences and has mutated to its current form. In this paper, we investigate the possibility of constructing an exponentially large number of sequences from a short initial sequence and simple replication rules, including those resembling genomic replication processes. In other words, our goal is to find out the capacity, or the expressive power, of these string-replication
systems. Our results include exact capacities, and
bounds on the capacities, of four fundamental string-replication systems.https://resolver.caltech.edu/CaltechAUTHORS:20140127-105959677Rate-Distortion for Ranking with Incomplete Information
https://resolver.caltech.edu/CaltechAUTHORS:20140127-104737329
Year: 2014
DOI: 10.48550/arXiv.1401.3093
We study the rate-distortion relationship in the set
of permutations endowed with the Kendall t-metric and the
Chebyshev metric. Our study is motivated by the application of permutation rate-distortion to the average-case and worst-case analysis of algorithms for ranking with incomplete information and approximate sorting algorithms. For the Kendall t-metric we provide bounds for small, medium, and large distortion regimes, while for the Chebyshev metric we present bounds that are valid for all distortions and are especially accurate for small
distortions. In addition, for the Chebyshev metric, we provide a construction for covering codes.https://resolver.caltech.edu/CaltechAUTHORS:20140127-104737329Asymmetric Error Correction and Flash-Memory Rewriting using Polar Codes
https://resolver.caltech.edu/CaltechAUTHORS:20150206-113520153
Year: 2015
DOI: 10.1109/TIT.2016.2539967
We propose efficient coding schemes for two communication settings: 1. asymmetric channels, and 2. channels
with an informed encoder. These settings are important in non-volatile memories, as well as optical and broadcast
communication. The schemes are based on non-linear polar codes, and they build on and improve recent work
on these settings. In asymmetric channels, we tackle the exponential storage requirement of previously known
schemes, that resulted from the use of large Boolean functions. We propose an improved scheme, that achieves the
capacity of asymmetric channels with polynomial computational complexity and storage requirement.
The proposed non-linear scheme is then generalized to the setting of channel coding with an informed encoder,
using a multicoding technique. We consider specific instances of the scheme for flash memories, that incorporate
error-correction capabilities together with rewriting. Since the considered codes are non-linear, they eliminate
the requirement of previously known schemes (called polar write-once-memory codes) for shared randomness
between the encoder and the decoder. Finally, we mention that the multicoding scheme is also useful for broadcast
communication in Marton's region, improving upon previous schemes for this setting.https://resolver.caltech.edu/CaltechAUTHORS:20150206-113520153Rewriting Flash Memories by Message Passing
https://resolver.caltech.edu/CaltechAUTHORS:20150209-161244506
Year: 2015
DOI: 10.48550/arXiv.1502.00189
This paper constructs WOM codes that combine
rewriting and error correction for mitigating the reliability and the endurance problems in flash memory.We consider a rewriting model that is of practical interest to flash applications where only the second write uses WOM codes. Our WOM code construction is based on binary erasure quantization with LDGM codes, where the rewriting uses message passing and has potential to share the
efficient hardware implementations with LDPC codes in practice. We show that the coding scheme achieves the capacity of the rewriting model. Extensive simulations show that the rewriting performance of our scheme compares favorably with that of polar WOM code in the rate region where high rewriting success probability is desired. We further augment our coding schemes with error correction capability. By drawing a connection to the
conjugate code pairs studied in the context of quantum error
correction, we develop a general framework for constructing
error-correction WOM codes. Under this framework, we give
an explicit construction of WOM codes whose codewords are
contained in BCH codes.https://resolver.caltech.edu/CaltechAUTHORS:20150209-161244506A Stochastic Model for Genomic Interspersed Duplication
https://resolver.caltech.edu/CaltechAUTHORS:20150209-161532302
Year: 2015
Mutation processes such as point mutation, insertion,
deletion, and duplication (including tandem and interspersed
duplication) have an important role in evolution, as
they lead to genomic diversity, and thus to phenotypic variation. In this work, we study the expressive power of interspersed duplication, i.e., its ability to generate diversity, via a simple but fundamental stochastic model, where the length and the location of the subsequence that is duplicated and the point of insertion of the copy are chosen randomly. In contrast to combinatorial models, where the goal is to determine the set of possible outcomes regardless of their likelihood, in stochastic
systems, we investigate the properties of the set of high-probability sequences. In particular we provide results regarding the asymptotic behavior of frequencies of symbols and short words in a sequence evolving through interspersed duplication. The study of such a systems is an important step towards the design and analysis of more realistic and sophisticated models of genomic mutation processes.https://resolver.caltech.edu/CaltechAUTHORS:20150209-161532302Capacity and Expressiveness of Genomic Tandem Duplication
https://resolver.caltech.edu/CaltechAUTHORS:20150209-155348874
Year: 2015
DOI: 10.48550/arXiv.1509.06029
The majority of the human genome consists of repeated sequences. An important type of repeats common in the human genome are tandem repeats, where identical copies appear next to each other. For example, in the sequence AGTCTGTGC, TGTG is a tandem repeat, namely, it was generated from AGTCTGC by tandem duplication of length 2. In this work, we investigate the possibility of generating a large number of sequences from a small initial string (called
the seed) by tandem duplication of length bounded by a constant. Our results include exact capacity values for certain tandem duplication string systems with alphabet sizes 2; 3; and 4. In addition, motivated by the role of DNA sequences in expressing proteins via RNA and the genetic code, we define the notion of the expressiveness of a tandem duplication system, as the feasibility of
expressing arbitrary substrings. We then completely characterize the expressiveness of tandem duplication systems for general alphabet sizes and duplication lengths. Noticing that a system with capacity = 1 is expressive, we prove that for an alphabet size ≥ 4, the capacity is strictly smaller than 1, independent of
the seed and the duplication lengths. The proof of this limit on the capacity (note that the genomic alphabet size is 4), is related to an interesting result by Axel Thue from 1906 which states that there exist arbitrary length sequences with no tandem repeats (square-free) for alphabet size ≥ 3. Finally, our results illustrate
that duplication lengths play a more significant role than the seed in generating a large number of sequences for these systems.https://resolver.caltech.edu/CaltechAUTHORS:20150209-155348874Communication Efficient Secret Sharing
https://resolver.caltech.edu/CaltechAUTHORS:20150529-105023455
Year: 2015
DOI: 10.1109/TIT.2016.2616144
A secret sharing scheme is a method to store information securely and reliably. Particularly, in the threshold secret sharing scheme (due to Shamir), a secret is divided
into shares, encoded and distributed to parties, such that any large enough collection of parties can decode the secret, and a smaller (then threshold) set of parties cannot
collude to deduce any information about the secret. While Shamir's scheme was studied for more than 35 years, the question of minimizing its communication bandwidth was
not considered. Specifically, assume that a user (or a collection of parties) wishes to decode the secret by receiving information from a set of parties; the question we
study is how to minimize the total amount of communication between the user and the parties. We prove a tight lower bound on the amount of communication necessary for
decoding, and construct secret sharing schemes achieving the bound. The key idea for achieving optimal communication bandwidth is to let the user receive information from
more than the necessary number of parties. In contrast, the current paradigm in secret sharing schemes is to decode from a minimum set of parties. Hence, existing secret
sharing schemes are not optimal in terms of communication bandwidth. In addition, we consider secure distributed storage where our proposed communication efficient secret
sharing schemes improve disk access complexity during decoding.https://resolver.caltech.edu/CaltechAUTHORS:20150529-105023455Efficiently Extracting Randomness from Imperfect Stochastic Processes
https://resolver.caltech.edu/CaltechAUTHORS:20160120-104324682
Year: 2016
DOI: 10.48550/arXiv.1209.0734
We study the problem of extracting a prescribed number of random bits by reading the smallest possible number of symbols from non-ideal stochastic processes. The related interval algorithm proposed by Han and Hoshi has asymptotically optimal performance; however, it assumes that the distribution of the input stochastic process is known. The motivation for our work is the fact that, in practice, sources of randomness have inherent correlations and are affected by measurement's noise. Namely, it is hard to obtain an accurate estimation of the distribution. This challenge was addressed by the concepts of seeded and seedless extractors that can handle general random sources with unknown distributions. However, known seeded and seedless extractors provide extraction efficiencies that are substantially smaller than Shannon's entropy limit. Our main contribution is the design of extractors that have a variable input-length and a fixed output length, are efficient in the consumption of symbols from the source, are capable of generating random bits from general stochastic processes and approach the information theoretic upper bound on efficiency.https://resolver.caltech.edu/CaltechAUTHORS:20160120-104324682Streaming Algorithms for Optimal Generation of Random Bits
https://resolver.caltech.edu/CaltechAUTHORS:20160120-102504919
Year: 2016
DOI: 10.48550/arXiv.1209.0730
Generating random bits from a source of biased coins (the biased is unknown) is a classical question that was originally studied by von Neumann. There are a number of known algorithms that have asymptotically optimal information efficiency, namely, the expected number of generated random bits per input bit is asymptotically close to the entropy of the source. However, only the original von Neumann algorithm has a 'streaming property' - it operates on a single input bit at a time and it generates random bits when possible, alas, it does not have an optimal information efficiency.
The main contribution of this paper is an algorithm that generates random bit streams from biased coins, uses bounded space and runs in expected linear time. As the size of the allotted space increases, the algorithm approaches the information-theoretic upper bound on efficiency. In addition, we discuss how to extend this algorithm to generate random bit streams from m-sided dice or correlated sources such as Markov chains.https://resolver.caltech.edu/CaltechAUTHORS:20160120-102504919Balanced Modulation for Nonvolatile Memories
https://resolver.caltech.edu/CaltechAUTHORS:20160120-083936607
Year: 2016
DOI: 10.48550/arXiv.1209.0744
This paper presents a practical writing/reading scheme in nonvolatile memories, called balanced modulation, for minimizing the asymmetric component of errors. The main idea is to encode data using a balanced error-correcting code. When reading information from a block, it adjusts the reading threshold such that the resulting word is also balanced or approximately balanced. Balanced modulation has suboptimal performance for any cell-level distribution and it can be easily implemented in the current systems of nonvolatile memories. Furthermore, we studied the construction of balanced error-correcting codes, in particular, balanced LDPC codes. It has very efficient encoding and decoding algorithms, and it is more efficient than prior construction of balanced error-correcting codes.https://resolver.caltech.edu/CaltechAUTHORS:20160120-083936607A Universal Scheme for Transforming Binary Algorithms to Generate Random Bits from Loaded Dice
https://resolver.caltech.edu/CaltechAUTHORS:20160120-102042704
Year: 2016
DOI: 10.48550/arXiv.1209.0726
In this paper, we present a universal scheme for transforming an arbitrary algorithm for biased 2-face coins to generate random bits from the general source of an m-sided die, hence enabling the application of existing algorithms to general sources. In addition, we study approaches of efficiently generating a prescribed number of random bits from an arbitrary biased coin. This contrasts with most existing works, which typically assume that the number of coin tosses is fixed, and they generate a variable number of random bits.https://resolver.caltech.edu/CaltechAUTHORS:20160120-102042704Systematic Codes for Rank Modulation
https://resolver.caltech.edu/CaltechAUTHORS:20160120-084734898
Year: 2016
DOI: 10.48550/arXiv.1311.7113
The goal of this paper is to construct systematic
error-correcting codes for permutations and multi permutations in the Kendall's τ-metric. These codes are
important in new applications such as rank modulation for
flash memories. The construction is based on error-correcting codes for multi-permutations and a partition of the set of permutations into error-correcting codes. For a given large enough number of information symbols k, and for any integer t, we present a construction for (k + r, k) systematic t-error-correcting codes, for permutations from S_(k+r), with less redundancy symbols than the number of redundancy symbols in the codes of the known constructions. In particular, for a given t and for sufficiently large k we can obtain r = t+1. The same construction is also applied to obtain related systematic error-correcting codes for multi-permutations.https://resolver.caltech.edu/CaltechAUTHORS:20160120-084734898Explicit MDS Codes for Optimal Repair Bandwidth
https://resolver.caltech.edu/CaltechAUTHORS:20160120-152728882
Year: 2016
DOI: 10.48550/arXiv.1411.6328
MDS codes are erasure-correcting codes that can correct the maximum number of erasures for a given number of
redundancy or parity symbols. If an MDS code has r parities and no more than r erasures occur, then by transmitting
all the remaining data in the code, the original information can be recovered. However, it was shown that in order
to recover a single symbol erasure, only a fraction of 1/r of the information needs to be transmitted. This fraction
is called the repair bandwidth (fraction). Explicit code constructions were given in previous works. If we view each
symbol in the code as a vector or a column over some field, then the code forms a 2D array and such codes are
especially widely used in storage systems. In this paper, we address the following question: given the length of the
column l, number of parities r, can we construct high-rate MDS array codes with optimal repair bandwidth of 1/r,
whose code length is as long as possible? In this paper, we give code constructions such that the code length is
(r +1) log_r l.https://resolver.caltech.edu/CaltechAUTHORS:20160120-152728882Secure RAID Schemes for Distributed Storage
https://resolver.caltech.edu/CaltechAUTHORS:20160125-120110556
Year: 2016
DOI: 10.1109/ISIT.2016.7541529
We propose secure RAID, i.e., low-complexity schemes to store information in a distributed manner that is resilient to node failures and resistant to node eavesdropping. We generalize the concept of systematic encoding to secure RAID and show that systematic schemes have significant advantages in the efficiencies of encoding, decoding and random access. For the practical high rate regime, we construct three XOR-based systematic secure RAID schemes with optimal or almost optimal encoding and
decoding complexities, from the EVENODD codes and B codes, which are array codes widely used in the RAID architecture. The schemes can tolerate up to two node failures and two eavesdropping nodes. For more general parameters we construct systematic secure RAID schemes from Reed-Solomon codes, and show that they are significantly more efficient than Shamir's secret sharing scheme. Our results suggest that building "keyless", information-theoretic security into the RAID architecture is practical.https://resolver.caltech.edu/CaltechAUTHORS:20160125-120110556Duplication-Correcting Codes for Data Storage in the DNA of Living Organisms
https://resolver.caltech.edu/CaltechAUTHORS:20160125-143414675
Year: 2016
DOI: 10.1109/ISIT.2016.7541455
The ability to store data in the DNA of a living
organism has applications in a variety of areas including synthetic biology and watermarking of patented genetically-modified organisms. Data stored in this medium is subject to errors arising from various mutations, such as point mutations, indels, and tandem duplication, which need to be corrected to maintain data integrity. In this paper, we provide error-correcting codes for errors caused by tandem duplications, which create a copy of a block of the sequence and insert it in a tandem manner, i.e., next
to the original. In particular, we present two families of codes for correcting errors due to tandem-duplications of a fixed length; the first family can correct any number of errors while the second corrects a bounded number of errors. We also study codes for correcting tandem duplications of length up to a given constant
k, where we are primarily focused on the cases of k = 2, 3.https://resolver.caltech.edu/CaltechAUTHORS:20160125-143414675The Synthesis and Analysis of Stochastic Switching Circuits
https://resolver.caltech.edu/CaltechAUTHORS:20160203-092316194
Year: 2016
DOI: 10.48550/arXiv.1209.0715
Stochastic switching circuits are relay circuits that
consist of stochastic switches called pswitches. The study of stochastic switching circuits has widespread applications in many fields of computer science, neuroscience, and biochemistry. In this paper, we discuss several properties of stochastic switching circuits, including robustness, expressibility, and probability approximation. First, we study the robustness, namely, the effect caused by introducing an error of size Є to each pswitch in a stochastic circuit. We analyze two constructions and prove that simple series-parallel circuits are robust to small error perturbations,
while general series-parallel circuits are not. Specifically, the total error introduced by perturbations of size less than Є is bounded by a constant multiple of Є in a simple series-parallel circuit, independent of the size of the circuit. Next, we study the expressibility of stochastic switching circuits: Given an integer q and a pswitch set S = {1/q,2/q,...,q-1/q}, can we synthesize any rational probability with denominator q^n (for arbitrary n) with a simple series-parallel stochastic switching
circuit? We generalize previous results and prove that when q is a multiple of 2 or 3, the answer is yes. We also show that when q is a prime number larger than 3, the answer is no. Probability approximation is studied for a general case of an arbitrary pswitch set S = {s_1, s_2,... , s_(|S|)}. In this case, we propose an algorithm based on local optimization to approximate any desired probability. The analysis reveals that the approximation error of a switching circuit decreases exponentially with an increasing circuit size.https://resolver.caltech.edu/CaltechAUTHORS:20160203-092316194Duplication Distance to the Root for Binary Sequences
https://resolver.caltech.edu/CaltechAUTHORS:20161108-134615672
Year: 2016
We study the tandem duplication distance between binary sequences and their roots. In other words, the quantity of interest is the number of tandem duplication operations of the form x = abc → y = abbc, where
x and y are sequences and a, b, and c are their substrings, needed to generate a binary sequence of length
n starting from a square-free sequence from the set
{0, 1, 01, 10, 010, 101}. This problem is a restricted case of finding the duplication/deduplication
distance between two sequences, defined as the minimum number of duplication and deduplication
operations required to transform one sequence to the other. We consider both exact and approximate tandem duplications. For exact duplication, denoting the maximum distance to the root of a sequence of length n by f(n), we prove that
f(n) = θ(n). For the case of approximate
duplication, where a β-fraction of symbols may be duplicated incorrectly, we show that the
maximum distance has a sharp transition from linear in n to logarithmic at β = 1/2. We also
study the duplication distance to the root for sequences with a given root and for special classes of
sequences, namely, the de Bruijn sequences, the Thue-Morse sequence, and the Fibbonaci words.
The problem is motivated by genomic tandem duplication mutations and the smallest number of
tandem duplication events required to generate a given biological sequence.https://resolver.caltech.edu/CaltechAUTHORS:20161108-134615672Noise and Uncertainty in String-Duplication Systems
https://resolver.caltech.edu/CaltechAUTHORS:20170119-133807104
Year: 2017
Duplication mutations play a critical role in the
generation of biological sequences. Simultaneously, they
have a deleterious effect on data stored using in-vivo DNA data storage. While duplications have been studied both as a sequence-generation mechanism and in the context of error correction, for simplicity these studies have not taken into account the presence of other types of mutations. In this work, we consider the capacity of duplication mutations in the presence of point-mutation
noise, and so quantify the generation power of these mutations. We show that if the number of point mutations is vanishingly small compared to the number of duplication mutations of a constant length, the generation capacity of these mutations is zero. However, if the number of point mutations increases to a constant fraction of the number of duplications, then the capacity is nonzero. Lower and upper bounds for this capacity are also presented. Another problem that we study is concerned with the
mismatch between code design and channel in data storage in the DNA of living organisms with respect to duplication mutations. In this context, we consider the uncertainty of such a mismatched coding scheme measured as the maximum number of input codewords that can lead to the same output.https://resolver.caltech.edu/CaltechAUTHORS:20170119-133807104Generic Secure Repair for Distributed Storage
https://resolver.caltech.edu/CaltechAUTHORS:20170713-092535943
Year: 2017
DOI: 10.48550/arXiv.1706.00500
This paper studies the problem of repairing secret sharing schemes, i.e., schemes that encode a message into n shares, assigned to n nodes, so that any n − r nodes can decode the message but any colluding z nodes cannot infer any information about the message. In the event of node failures so that shares held by the failed nodes are lost, the system needs to be repaired by
reconstructing and reassigning the lost shares to the failed (or replacement) nodes. This can be achieved trivially by a trustworthy third-party that receives the shares of the available nodes, recompute and reassign the lost shares. The interesting question, studied in the paper, is how to repair without a trustworthy third-party. The main issue that arises is repair security: how to maintain the
requirement that any colluding z nodes, including the failed nodes, cannot learn any information about the message, during and after the repair process? We solve this secure repair problem from the perspective of secure multi-party computation. Specifically, we design generic repair schemes that can securely repair any (scalar or vector) linear secret sharing schemes. We prove a lower bound on the repair bandwidth of secure repair schemes and show that the proposed secure repair schemes achieve the optimal
repair bandwidth up to a small constant factor when
n dominates z, or when the secret sharing scheme being repaired has optimal rate. We adopt a formal information-theoretic approach in our analysis and bounds. A main idea in our schemes is to allow a more flexible repair model than the straightforward one-round repair model implicitly assumed by existing secure regenerating codes. Particularly, the proposed secure repair schemes are simple and efficient two-round protocols.https://resolver.caltech.edu/CaltechAUTHORS:20170713-092535943Attaining the 2nd Chargaff Rule by Tandem Duplications
https://resolver.caltech.edu/CaltechAUTHORS:20180105-092230028
Year: 2018
Erwin Chargaff in 1950 made an experimental observation that the count of A is equal to the count of T and the count of C is equal to the count of G in DNA. This observation played a crucial rule in the discovery of the double stranded helix structure by Watson and Crick. However, this symmetry was also observed in single stranded DNA. This phenomenon was termed as 2nd Chargaff Rule. This symmetry has been verified experimentally in genomes of several different species not only for mononucleotides but also for reverse complement pairs of larger lengths up to a small error. While the symmetry in double stranded DNA is related to base pairing, and replication mechanisms, the symmetry in a single stranded DNA is still a mystery in its function and source. In this work, we define a sequence generation model based on reverse complement tandem duplications. We show that this model generates sequences that satisfy the 2nd Chargaff Rule even when the duplication lengths are very small when compared to the length of sequences. We also provide estimates on the number of generations that are needed by this model to generate sequences that satisfy 2nd Chargaff Rule. We provide theoretical bounds on the disruption in symmetry for different values of duplication lengths under this model. Moreover, we experimentally compare the disruption in the symmetry incurred by our model with what is observed in human genome data.https://resolver.caltech.edu/CaltechAUTHORS:20180105-092230028Two Deletion Correcting Codes from Indicator Vectors
https://resolver.caltech.edu/CaltechAUTHORS:20180709-102730008
Year: 2018
Construction of capacity achieving deletion correcting codes has been a baffling challenge for decades. A recent breakthrough by Brakensiek et al., alongside novel applications in DNA storage, have reignited the interest in this longstanding open problem. In spite of recent advances, the amount of redundancy in existing codes is still orders of magnitude away from being optimal. In this paper, a novel approach for constructing binary two-deletion correcting codes is proposed. By this approach, parity symbols are computed from indicator vectors (i.e., vectors that indicate the positions of certain patterns) of the encoded message, rather than from the message itself. Most interestingly, the parity symbols and the proof of correctness are a direct generalization of their counterparts in the Varshamov-Tenengolts construction. Our techniques require 7 log(n) + o(log(n) redundant bits to encode an n-bit message, which is near-optimal.https://resolver.caltech.edu/CaltechAUTHORS:20180709-102730008Secret Sharing with Optimal Decoding and Repair Bandwidth
https://resolver.caltech.edu/CaltechAUTHORS:20180709-102239656
Year: 2018
This paper studies the communication efficiency of threshold secret sharing schemes. We construct a family of Shamir's schemes with asymptotically optimal decoding bandwidth for arbitrary parameters. We also construct a family of secret sharing schemes with both optimal decoding bandwidth and optimal repair bandwidth for arbitrary parameters. The construction also leads to a family of regenerating codes allowing centralized repair of multiple node failures with small sub-packetization.https://resolver.caltech.edu/CaltechAUTHORS:20180709-102239656Secure RAID Schemes from EVENODD and STAR Codes
https://resolver.caltech.edu/CaltechAUTHORS:20180709-101600551
Year: 2018
We study secure RAID, i.e., low-complexity schemes to store information in a distributed manner that is resilient to node failures and resistant to node eavesdropping. We describe a technique to shorten the secure EVENODD scheme in [6], which can optimally tolerate 2 node failures and 2 eavesdropping nodes. The shortening technique allows us to obtain secure EVENODD schemes of arbitrary lengths, which is important for practical application. We also construct a new secure RAID scheme from the STAR code. The scheme can tolerate 3 node failures and 3 eavesdropping nodes with optimal encoding/decoding and random access complexity.https://resolver.caltech.edu/CaltechAUTHORS:20180709-101600551The Capacity of Some Pólya String Models
https://resolver.caltech.edu/CaltechAUTHORS:20180820-100255874
Year: 2018
We study random string-duplication systems, which we call Pólya string models. These are motivated by DNA storage in living organisms, and certain random mutation processes that affect their genome. Unlike previous works that study the combinatorial capacity of string-duplication systems, or various string statistics, this work provides exact capacity or bounds on it, for several probabilistic models. In particular, we study the capacity of noisy string-duplication systems, including the tandem-duplication, end-duplication, and interspersed-duplication systems. Interesting connections are drawn between some systems and the signature of random permutations, as well as to the beta distribution common in population genetics.https://resolver.caltech.edu/CaltechAUTHORS:20180820-100255874On Coding over Sliced Information
https://resolver.caltech.edu/CaltechAUTHORS:20181002-162910265
Year: 2018
The interest in channel models in which the data is sent as an unordered set of binary strings has increased lately, due to emerging applications in DNA storage, among others. In this paper we analyze the minimal redundancy of binary codes for this channel under substitution errors, and provide several constructions, some of which are shown to be asymptotically optimal. The surprising result in this paper is that while the information vector is sliced into a set of unordered strings, the amount of redundant bits that are required to correct errors is asymptotically equal to the amount required in the classical error correcting paradigm.https://resolver.caltech.edu/CaltechAUTHORS:20181002-162910265Cancer Classification from Healthy DNA using Machine Learning
https://resolver.caltech.edu/CaltechAUTHORS:20190114-074334836
Year: 2019
DOI: 10.1101/517839
The genome is traditionally viewed as a time-independent source of information; a paradigm that drives researchers to seek correlations between the presence of certain genes and a patient's risk of disease. This analysis neglects genomic temporal changes, which we believe to be a crucial signal for predicting an individual's susceptibility to cancer. We hypothesize that each individual's genome passes through an evolution channel (The term channel is motivated by the notion of communication channel introduced by Shannon in 1948 and started the area of Information Theory), that is controlled by hereditary, environmental and stochastic factors. This channel differs among individuals, giving rise to varying predispositions to developing cancer. We introduce the concept of mutation profiles that are computed without any comparative analysis, but by analyzing the short tandem repeat regions in a single healthy genome and capturing information about the individual's evolution channel. Using machine learning on data from more than 5,000 TCGA cancer patients, we demonstrate that these mutation profiles can accurately distinguish between patients with various types of cancer. For example, the pairwise validation accuracy of the classifier between PAAD (pancreas) patients and GBM (brain) patients is 93%. Our results show that healthy unaffected cells still contain a cancer-specific signal, which opens the possibility of cancer prediction from a healthy genome.https://resolver.caltech.edu/CaltechAUTHORS:20190114-074334836Short Tandem Repeats Information in TCGA is Statistically Biased by Amplification
https://resolver.caltech.edu/CaltechAUTHORS:20190114-091231818
Year: 2019
DOI: 10.1101/518878
The current paradigm in data science is based on the belief that given sufficient amounts of data, classifiers are likely to uncover the distinction between true and false hypotheses. In particular, the abundance of genomic data creates opportunities for discovering disease risk associations and help in screening and treatment. However, working with large amounts of data is statistically beneficial only if the data is statistically unbiased. Here we demonstrate that amplification methods of DNA samples in TCGA have a substantial effect on short tandem repeat (STR) information. In particular, we design a classifier that uses the STR information and can distinguish between samples that have an analyte code D and an analyte code W. This artificial bias might be detrimental to data driven approaches, and might undermine the conclusions based on past and future genome wide studies.https://resolver.caltech.edu/CaltechAUTHORS:20190114-091231818Download and Access Trade-offs in Lagrange Coded Computing
https://resolver.caltech.edu/CaltechAUTHORS:20190220-123432908
Year: 2019
Lagrange Coded Computing (LCC) is a recently
proposed technique for resilient, secure, and private computation
of arbitrary polynomials in distributed environments. By
mapping such computations to composition of polynomials, LCC
allows the master node to complete the computation by accessing
a minimal number of workers and downloading all of their
content, thus providing resiliency to the remaining stragglers.
However, in the most common case in which the number of
stragglers is less than in the worst case scenario, much of the
computational power of the system remains unexploited. To
amend this issue, in this paper we expand LCC by studying a
fundamental trade-off between download and access, and present
two contributions. In the first contribution, it is shown that
without any modification to the encoding process, the master
can decode the computations by accessing a larger number of
nodes, however downloading less information from each node in
comparison with LCC (i.e., trading access for download). This
scheme relies on decoding a particular polynomial in the ideal
that is generated by the polynomials of interest, a technique we
call Ideal Decoding. This new scheme also improves LCC in the
sense that for systems with adversaries, the overall downloaded
bandwidth is smaller than in LCC. In the second contribution
we study a real-time model of this trade-off, in which the data
from the workers is downloaded sequentially. By clustering nodes
of similar delays and encoding the function with Universally
Decodable Matrices, the master can decode once sufficient data is
downloaded from every cluster, regardless of the internal delays
within that cluster. This allows the master to utilize the partial
work that is done by stragglers, rather than to ignore it, a feature
that most past works in coded computing are lacking.https://resolver.caltech.edu/CaltechAUTHORS:20190220-123432908Generating Probability Distributions using Multivalued Stochastic Relay Circuits
https://resolver.caltech.edu/CaltechAUTHORS:20191004-150014222
Year: 2019
DOI: 10.48550/arXiv.1102.1441
The problem of random number generation dates back to von Neumann's work in 1951. Since then, many algorithms have been developed for generating unbiased bits from complex correlated sources as well as for generating arbitrary distributions from unbiased bits. An equally interesting, but less studied aspect is the structural component of random number generation as opposed to the algorithmic aspect. That is, given a network structure imposed by nature or physical devices, how can we build networks that generate arbitrary probability distributions in an optimal way? In this paper, we study the generation of arbitrary probability distributions in multivalued relay circuits, a generalization in which relays can take on any of N states and the logical 'and' and 'or' are replaced with 'min' and 'max' respectively. Previous work was done on two-state relays. We generalize these results, describing a duality property and networks that generate arbitrary rational probability distributions. We prove that these networks are robust to errors and design a universal probability generator which takes input bits and outputs arbitrary binary probability distributions.https://resolver.caltech.edu/CaltechAUTHORS:20191004-150014222On Codes for Optimal Rebuilding Access
https://resolver.caltech.edu/CaltechAUTHORS:20191004-150559432
Year: 2019
DOI: 10.48550/arXiv.1107.1627
MDS (maximum distance separable) array codes are widely used in storage systems due to their computationally efficient encoding and decoding procedures. An MDS code with r redundancy nodes can correct any r erasures by accessing (reading) all the remaining information in both the systematic nodes and the parity (redundancy) nodes. However, in practice, a single erasure is the most likely failure event; hence, a natural question is how much information do we need to access in order to rebuild a single storage node? We define the rebuilding ratio as the fraction of remaining information accessed during the rebuilding of a single erasure. In our previous work we showed that the optimal rebuilding ratio of 1/r is achievable (using our newly constructed array codes) for the rebuilding of any systematic node, however, all the information needs to be accessed for the rebuilding of the parity nodes. Namely, constructing array codes with a rebuilding ratio of 1/r was left as an open problem. In this paper, we solve this open problem and present array codes that achieve the lower bound of 1/r for rebuilding any single systematic or parity node.https://resolver.caltech.edu/CaltechAUTHORS:20191004-150559432Generic Secure Repair for Distributed Storage
https://resolver.caltech.edu/CaltechAUTHORS:20191004-142514161
Year: 2019
DOI: 10.48550/arXiv.1706.00500
This paper studies the problem of repairing secret sharing schemes, i.e., schemes that encode a message into n shares, assigned to n nodes, so that any n−r nodes can decode the message but any colluding z nodes cannot infer any information about the message. In the event of node failures so that shares held by the failed nodes are lost, the system needs to be repaired by reconstructing and reassigning the lost shares to the failed (or replacement) nodes. This can be achieved trivially by a trustworthy third-party that receives the shares of the available nodes, recompute and reassign the lost shares. The interesting question, studied in the paper, is how to repair without a trustworthy third-party. The main issue that arises is repair security: how to maintain the requirement that any colluding z nodes, including the failed nodes, cannot learn any information about the message, during and after the repair process? We solve this secure repair problem from the perspective of secure multi-party computation. Specifically, we design generic repair schemes that can securely repair any (scalar or vector) linear secret sharing schemes. We prove a lower bound on the repair bandwidth of secure repair schemes and show that the proposed secure repair schemes achieve the optimal repair bandwidth up to a small constant factor when n dominates z, or when the secret sharing scheme being repaired has optimal rate. We adopt a formal information-theoretic approach in our analysis and bounds. A main idea in our schemes is to allow a more flexible repair model than the straightforward one-round repair model implicitly assumed by existing secure regenerating codes. Particularly, the proposed secure repair schemes are simple and efficient two-round protocols.https://resolver.caltech.edu/CaltechAUTHORS:20191004-142514161Rate-Distortion for Ranking with Incomplete Information
https://resolver.caltech.edu/CaltechAUTHORS:20191004-151348066
Year: 2019
DOI: 10.48550/arXiv.1401.3093
We study the rate-distortion relationship in the set of permutations endowed with the Kendall Tau metric and the Chebyshev metric. Our study is motivated by the application of permutation rate-distortion to the average-case and worst-case analysis of algorithms for ranking with incomplete information and approximate sorting algorithms. For the Kendall Tau metric we provide bounds for small, medium, and large distortion regimes, while for the Chebyshev metric we present bounds that are valid for all distortions and are especially accurate for small distortions. In addition, for the Chebyshev metric, we provide a construction for covering codes.https://resolver.caltech.edu/CaltechAUTHORS:20191004-151348066Linear Transformations for Randomness Extraction
https://resolver.caltech.edu/CaltechAUTHORS:20191004-151746022
Year: 2019
DOI: 10.48550/arXiv.1209.0732
Information-efficient approaches for extracting randomness from imperfect sources have been extensively studied, but simpler and faster ones are required in the high-speed applications of random number generation. In this paper, we focus on linear constructions, namely, applying linear transformation for randomness extraction. We show that linear transformations based on sparse random matrices are asymptotically optimal to extract randomness from independent sources and bit-fixing sources, and they are efficient (may not be optimal) to extract randomness from hidden Markov sources. Further study demonstrates the flexibility of such constructions on source models as well as their excellent information-preserving capabilities. Since linear transformations based on sparse random matrices are computationally fast and can be easy to implement using hardware like FPGAs, they are very attractive in the high-speed applications. In addition, we explore explicit constructions of transformation matrices. We show that the generator matrices of primitive BCH codes are good choices, but linear transformations based on such matrices require more computational time due to their high densities.https://resolver.caltech.edu/CaltechAUTHORS:20191004-151746022The Capacity of String-Replication Systems
https://resolver.caltech.edu/CaltechAUTHORS:20191004-144116872
Year: 2019
DOI: 10.48550/arXiv.1401.4634
It is known that the majority of the human genome consists of repeated sequences. Furthermore, it is believed that a significant part of the rest of the genome also originated from repeated sequences and has mutated to its current form. In this paper, we investigate the possibility of constructing an exponentially large number of sequences from a short initial sequence and simple replication rules, including those resembling genomic replication processes. In other words, our goal is to find out the capacity, or the expressive power, of these string-replication systems. Our results include exact capacities, and bounds on the capacities, of four fundamental string-replication systems.https://resolver.caltech.edu/CaltechAUTHORS:20191004-144116872Optimal k-Deletion Correcting Codes
https://resolver.caltech.edu/CaltechAUTHORS:20200409-105733198
Year: 2020
Levenshtein introduced the problem of constructing k-deletion correcting codes in 1966, proved that the optimal redundancy
of those codes is O(k log N), and proposed an optimal redundancy single-deletion correcting code (using the so-called VT
construction). However, the problem of constructing optimal redundancy k-deletion correcting codes remained open. Our key
contribution is a solution to this longstanding open problem. We present a k-deletion correcting code that has redundancy 8k log n+
o(log n) and encoding/decoding algorithms of complexity O(n^(2k+1)) for constant k.https://resolver.caltech.edu/CaltechAUTHORS:20200409-105733198Cancer Classification from Blood-Derived DNA
https://resolver.caltech.edu/CaltechAUTHORS:20200423-125742527
Year: 2020
DOI: 10.1101/517839
The genome is traditionally viewed as a time-independent source of information; a paradigm that drives researchers to seek correlations between the presence of certain genes and a patient's risk of disease. This analysis neglects genomic temporal changes, which we believe to be a crucial signal for predicting an individual's susceptibility to cancer. We hypothesize that each individual's genome passes through an evolution channel (The term channel is motivated by the notion of communication channel introduced by Shannon in 1948 and started the area of Information Theory), that is controlled by hereditary, environmental and stochastic factors. This channel differs among individuals, giving rise to varying predispositions to developing cancer. We introduce the concept of mutation profiles that are computed without any comparative analysis, but by analyzing the short tandem repeat regions in a single healthy genome and capturing information about the individual's evolution channel. Using machine learning on data from more than 5,000 TCGA cancer patients, we demonstrate that these mutation profiles can accurately distinguish between patients with various types of cancer. For example, the pairwise validation accuracy of the classifier between PAAD (pancreas) patients and GBM (brain) patients is 93%. Our results show that healthy unaffected cells still contain a cancer-specific signal, which opens the possibility of cancer prediction from a healthy genome.https://resolver.caltech.edu/CaltechAUTHORS:20200423-125742527CodNN - Robust Neural Networks From Coded Classification
https://resolver.caltech.edu/CaltechAUTHORS:20200427-091132325
Year: 2020
Deep Neural Networks (DNNs) are a revolutionary force in the ongoing information revolution, and yet their intrinsic properties remain a mystery. In particular, it is widely known that DNNs are highly sensitive to noise, whether adversarial or random. This poses a fundamental challenge for hardware implementations of DNNs, and for their deployment in critical applications such as autonomous driving.
In this paper we construct robust DNNs via error correcting codes. By our approach, either the data or internal layers of the DNN are coded with error correcting codes, and successful computation under noise is guaranteed. Since DNNs can be seen as a layered concatenation of classification tasks, our research begins with the core task of classifying noisy coded inputs, and progresses towards robust DNNs.
We focus on binary data and linear codes. Our main result is that the prevalent parity code can guarantee robustness for a large family of DNNs, which includes the recently popularized binarized neural networks. Further, we show that the coded classification problem has a deep connection to Fourier analysis of Boolean functions.
In contrast to existing solutions in the literature, our results do not rely on altering the training process of the DNN, and provide mathematically rigorous guarantees rather than experimental evidence.https://resolver.caltech.edu/CaltechAUTHORS:20200427-091132325Coding for Optimized Writing Rate in DNA Storage
https://resolver.caltech.edu/CaltechAUTHORS:20200511-120246633
Year: 2020
A method for encoding information in DNA sequences is described. The method is based on the precision-resolution framework, and is aimed to work in conjunction with a recently suggested terminator-free template independent DNA synthesis method. The suggested method optimizes the amount of information bits per synthesis time unit, namely, the writing rate. Additionally, the encoding scheme studied here takes into account the existence of multiple copies of the DNA sequence, which are independently distorted. Finally, quantizers for various run-length distributions are designed.https://resolver.caltech.edu/CaltechAUTHORS:20200511-120246633Robust Correction of Sampling Bias Using Cumulative Distribution Functions
https://resolver.caltech.edu/CaltechAUTHORS:20210624-211933517
Year: 2021
Varying domains and biased datasets can lead to differences between the training and the target distributions, known as covariate shift. Current approaches for alleviating this often rely on estimating the ratio of training and target probability density functions. These techniques require parameter tuning and can be unstable across different datasets. We present a new method for handling covariate shift using the empirical cumulative distribution function estimates of the target distribution by a rigorous generalization of a recent idea proposed by Vapnik and Izmailov. Further, we show experimentally that our method is more robust in its predictions, is not reliant on parameter tuning and shows similar classification performance compared to the current state-of-the-art techniques on synthetic and real datasets.https://resolver.caltech.edu/CaltechAUTHORS:20210624-211933517Synthesizing New Expertise via Collaboration
https://resolver.caltech.edu/CaltechAUTHORS:20210624-214158214
Year: 2021
Consider a set of classes and an uncertain input. Suppose, we do not have access to data and only have knowledge of perfect experts between a few classes in the set. What constitutes a consistent set of opinions? How can we use this to predict the opinions of experts on missing sub-domains? In this paper, we define a framework to analyze this problem. In particular, we define an expert graph where vertices represent classes and edges represent binary experts on the topics of their vertices. We derive necessary conditions for an expert graph to be valid. Further, we show that these conditions are also sufficient if the graph is a cycle, which can yield unintuitive results. Using these conditions, we provide an algorithm to obtain upper and lower bounds on the weights of unknown edges in an expert graph.https://resolver.caltech.edu/CaltechAUTHORS:20210624-214158214Trace Reconstruction with Bounded Edit Distance
https://resolver.caltech.edu/CaltechAUTHORS:20210624-215307865
Year: 2021
The trace reconstruction problem studies the number of noisy samples needed to recover an unknown string x ∈ {0, 1}^n with high probability, where the samples are independently obtained by passing x through a random deletion channel with deletion probability p. The problem is receiving significant attention recently due to its applications in DNA sequencing and DNA storage. Yet, there is still an exponential gap between upper and lower bounds for the trace reconstruction problem. In this paper we study the trace reconstruction problem when x is confined to an edit distance ball of radius k, which is essentially equivalent to distinguishing two strings with edit distance at most k. It is shown that n
O(k) samples suffice to achieve this task with high probability.https://resolver.caltech.edu/CaltechAUTHORS:20210624-215307865Neural Networks Computations with DOMINATION Functions
https://resolver.caltech.edu/CaltechAUTHORS:20210624-214748102
Year: 2021
We study a new representation of neural networks based on DOMINATION functions. Specifically, we show that a threshold function can be computed by its variables connected via an unweighted bipartite graph to a universal gate computing a DOMINATION function. The DOMINATION function consists of fixed weights that are ascending powers of 2. We derive circuit-size upper and lower bounds for circuits with small weights that compute DOMINATION functions. Interestingly, the circuit-size bounds are dependent on the sparsity of the
bipartite graph. In particular, functions with sparsity 1 (like the EQUALITY function) can be implemented by small-size constant-weight circuits.https://resolver.caltech.edu/CaltechAUTHORS:20210624-214748102Expert Graphs: Synthesizing New Expertise via Collaboration
https://resolver.caltech.edu/CaltechAUTHORS:20220804-201308000
Year: 2022
DOI: 10.48550/arXiv.2107.07054
Consider multiple experts with overlapping expertise working on a classification problem under uncertain input. What constitutes a consistent set of opinions? How can we predict the opinions of experts on missing sub-domains? In this paper, we define a framework of to analyze this problem, termed "expert graphs." In an expert graph, vertices represent classes and edges represent binary opinions on the topics of their vertices. We derive necessary conditions for expert graph validity and use them to create "synthetic experts" which describe opinions consistent with the observed opinions of other experts. We show this framework to be equivalent to the well-studied linear ordering polytope. We show our conditions are not sufficient for describing all expert graphs on cliques, but are sufficient for cycles.https://resolver.caltech.edu/CaltechAUTHORS:20220804-201308000Correcting k Deletions and Insertions in Racetrack Memory
https://resolver.caltech.edu/CaltechAUTHORS:20220804-201302433
Year: 2022
DOI: 10.48550/arXiv.2207.08372
One of the main challenges in developing racetrack memory systems is the limited precision in controlling the track shifts, that in turn affects the reliability of reading and writing the data. A current proposal for combating deletions in racetrack memories is to use redundant heads per-track resulting in multiple copies (potentially erroneous) and recovering the data by solving a specialized version of a sequence reconstruction problem. Using this approach, k-deletion correcting codes of length n, with d≥2 heads per-track, with redundancy loglogn+4 were constructed. However, the known approach requires that k≤d, namely, that the number of heads (d) is larger than or equal to the number of correctable deletions (k). Here we address the question: What is the best redundancy that can be achieved for a k-deletion code (k is a constant) if the number of heads is fixed at d (due to implementation constraints)? One of our key results is an answer to this question, namely, we construct codes that can correct k deletions, for any k beyond the known limit of d. The code has 4k log log n + o(log log n) redundancy for k ≤ 2d − 1. In addition, when k ≥ 2d, our codes have 2⌊k/d⌋log n + o (log n) redundancy, that we prove it is order-wise optimal, specifically, we prove that the redundancy required for correcting k deletions is at least ⌊k/d⌋log n + o(log n). The encoding/decoding complexity of our codes is O(n log²ᵏ n). Finally, we ask a general question: What is the optimal redundancy for codes correcting a combination of at most k deletions and insertions in a d-head racetrack memory? We prove that the redundancy sufficient to correct a combination of k deletion and insertion errors is similar to the case of k deletion errors.https://resolver.caltech.edu/CaltechAUTHORS:20220804-201302433Timing Analysis of Cyclic Combinational Circuits
https://resolver.caltech.edu/CaltechPARADISE:2004.ETR060.1159
Year: 2023
The accepted wisdom is that combinational circuits must have acyclic (i.e., loop-free or feed-forward) topologies. And yet simple examples suggest that this need not be so. In previous work, we advocated the design of cyclic combinational circuits (i.e., circuits with loops or feedback paths). We proposed a methodology for analyzing and synthesizing such circuits, with an emphasis on the optimization of area.
In this paper, we extend our methodology into the temporal realm. We characterize the true delay of cyclic circuits through symbolic event propagation in the floating mode of operation, according to the up-bounded inertial delay model. We present analysis results for circuits optimized with our program CYCLIFY. Some benchmark circuits were optimized significantly, with simultaneous improvements of up to 10% in the area and 25% in the delay.https://resolver.caltech.edu/CaltechPARADISE:2004.ETR060.1159