Expert answer:Computer Science, read and summarize help

Answer & Explanation:I want you to summarize each document and write one to two pages (Font 11 double space) for each document.  ch2_1.pdfch3_2.pdfch3_1.pdfch2_2.pdf
ch2_1.pdf

ch3_2.pdf

ch3_1.pdf

ch2_2.pdf

Unformatted Attachment Preview

I. Peterson, “Monte Carlo Physics: A Cautionary Lesson,” Science
News, v. 142, n. 25, 19 Dec 1992, p. 422.
To simulate chance occurrences, a computer can’t literally toss a coin or roll a die.
Instead, it relies on special numerical recipes for generating strings of shuffled digits that
pass for random numbers. Such sequences of pseudorandom numbers play crucial roles
not only in computer games but also in simulations of physical processes.
Researchers have long known that the use of particular methods for generating random
numbers can produce misleading results in simulations. Now Alan M. Ferrenberg, a
computational physicist at the University of Georgia in Athens, and his coworkers have
discovered that even “high-quality” random-number generators, which pass a battery of
randomness tests, can yield incorrect results under certain circumstances.
The researchers report the findings in the Dec. 7 PHYSICAL REVIEW LETTERS.
Initially, the approach taken by Ferrenberg and his coworkers looked promising. They
were interested in simulating the so-called Ising model, which features an abrupt,
temperature-dependent transition from an ordered to a disordered state in a system in
which neighboring particles have either the same or opposite spins.
To accomplish this goal, they selected a spin-flipping algorithm recently developed by
Ulli Wolff of the University of Kiel in Germany and the new “subtract-with-borrow”
random-number generator of George Marsaglia and Arif Zaman of Florida State
University in Tallahassee (SN: 11/9/91, p.300). In preparation for simulating the threedimensional Ising model, Ferrenberg tested this package on the two-dimensional
version, which has a known answer. “I got the wrong result;’ Ferrenberg says.
Believing that the problem lay in how he had written his computer program, Ferrenberg
spent three weeks looking for errors, but he found none. “As far as we could tell, we had
exhausted every possibility – except the random-number generator,” he remarks.
As a last resort, Ferrenberg substituted different random-number generators and, to his
surprise, found that he came much closer to the correct answer by using a linear
congruential generator, which has known defects.
“What we got out of this was that some random-number generators will work with one
simulation algorithm and not with others,” Ferrenberg says. “It’s very discouraging.”
“I am not at all surprised at the kind of results observed,” comments J.A. Reeds of AT&T
Bell Laboratories in Murray Hill, N.J. Reeds had encountered a similar problem with the
Marsaglia-Zaman random-number generators in a different type of computation.
In an additional twist on the curious behavior of random-number generators, Shu Tezuka
of the IBM Tokyo Research Laboratory in Japan and Pierre L’Ecuyer of the University of
Montreal in Quebec have now proved that the MarsagliaZaman random-number
generators are .essentially equivalent” to linear congruential methods. Therefore, these
generators share many of the same characteristics and faults.
L’Ecuyer presented this analysis at this week’s Winter Simulation Conference, held in
Arlington, Va.
The uncertainty about how subtle, hidden patterns among digits spewed out by various
random-number generators may influence simulation results presents researchers using
so-called Monte Carlo methods with a serious dilemma, especially when the answer is
not known.
“Since there is no reason to believe that the model which we have investigated has any
special idiosyncrasies, these results offer another stern warning about the need to very
carefully test the implementation of new algorithms,” Ferrenberg and his coworkers
conclude. “In particular, this means that a specific algorithm must be tested together with
the random-number generator being used regardless of the tests which the generator
has passed.”
~~~~~~~~
By L. Peterson
Enhancing Privacy through Negative Representations of Data∗
Fernando Esponda, Stephanie Forrest and Paul Helman
Department of Computer Science
University of New Mexico
Albuquerque, NM 87131-1386
{fesponda,forrest,helman}@cs.unm.edu
Abstract
The paper introduces the concept of a negative database, in which a set of records DB is represented by
its complement set. That is, all the records not in DB are represented, and DB itself is not explicitly
stored. After introducing the concept, several results are given regarding the feasibility of such a scheme
and its potential for enhancing privacy. It is shown that a database consisting of n, l-bit records can
be represented negatively using only O(ln) records. It is also shown that membership queries for DB
can be processed against the negative representation in time no worse than linear in its size and that
reconstructing the database DB represented by a negative database N DB given as input is an N P-hard
problem when time complexity is measured as a function of the size of N DB.
1
Introduction
Large collections of data are ubiquitous, and the demands that will be placed on these collections in the
near future are increasing. We expect them to be available when we need them; we expect them not to
be available to malicious parties; the contents of the collections and the rules for accessing them must be
continually updated; we would like to be able to search them in new ways, drawing inferences about largescale patterns and trends; we want to be protected from the wrong kinds of inferences being made (as in
racial profiling); and, eventually, we will want the ability to audit the uses to which our personal data are
put. Although many of these problems are old, they must now be solved more quickly for larger and more
dynamic collections of data.
In this paper we introduce an approach to representing data that addresses some of these issues. In
our approach, the negative image of a set of data records is represented rather than the records themselves
(Figure 2). Initially, we assume a universe U of finite-length records (or strings), all of the same length l,
and defined over a binary alphabet. We logically divide the space of possible strings into two disjoint sets:
DB representing the set positive records (holding the information of interest), and U − DB denoting the set
of all strings not in DB. We assume that DB is uncompressed (each record is represented explicitly), but
we allow U − DB to be stored in a compressed form called N DB. We refer to DB as the positive database
and N DB as the negative database.
From a logical point of view, either representation will suffice to answer questions regarding DB. However,
the different representations may present different advantages. For instance, in a positive database, inspection
of a single record provides meaningful information. However, inspection of a single (negative) record reveals
little meaningful information about the contents of the original database. Because the positive tuples are
never stored explicitly, a negative database would be much more difficult to misuse. Similarly, depending on
the representation for N DB, the efficiency of certain kinds of queries may be significantly different than the
efficiency of the same query under DB.
∗ University
of New Mexico Technical Report.
1
Some applications may benefit from this change of perspective. Most applications seek to retrieve information about DB as efficiently and accurately as possible, and they typically are not explicitly concerned
with U − DB. Yet, in situations where privacy is a concern it may be useful to adopt a scheme in which
certain queries are efficient and others are provably inefficient.
Current technologies of encryption (for the data itself) and query restriction (for controlling access to
the data) help ensure confidentiality, but neither solution is appropriate for all applications. In the case of
encryption, the ability to search data records is hindered, while in the case of query restriction, individual
records are vulnerable to insider attacks. The method presented here potentially addresses both of these
concerns.
In the following sections, we first show that implementing N DB is computationally feasible. We do this
by introducing a representational scheme that requires O(ln) negative records to represent a positive database
consisting of n, l-bit records, and then giving an algorithm for finding such a representation efficiently from
any finite DB. This representation is known as the prefix representation. The prefix representation supports
simple membership queries1 , insertions, and deletions. We then investigate some of the implications of
the negative scheme for privacy. In particular, we show that the general problem of recovering a positive
database from our negative representation is N P-hard, and we present a randomized algorithm for creating
negative representations that are difficult to reverse. Finally, we review related work, discuss the potential
consequences of our results, and outline areas of future investigation.
2
Representation
In order to create a database N DB that is reasonable in size, we must compress the information contained
in U − DB but retain the ability to answer queries. We introduce one additional symbol to our binary
alphabet, known as a “don’t care,” written as ∗. The entries in N DB will thus be l-length strings over the
alphabet {0, 1, ∗}. The don’t-care symbol has the usual interpretation and will match either a one or a zero
at the bit position where the ∗ appears. Positions in a string that are set either to one or zero are referred
to as “defined positions.” With this new symbol we can potentially represent large subsets of U − DB with
just a few entries.
For example, the set of strings U − DB can be exactly represented by the N DB set depicted shown
below:
DB
000
111
(U − DB)
001
010
011
100
101
110
N DB
⇒
0*1
*10
10*
The convention is that a string s is taken to be in DB if and only if s fails to match all the entries in N DB.
This condition is fulfilled only if for every string tj ∈ N DB, s disagrees with tj in at least one defined
position.
2.1
The Prefix Algorithm
In this section we present an algorithm as proof that a negative database N DB can be constructed in
reasonable time and of reasonable size. The prefix algorithm introduced here is deterministic and reversible,
which has consequences for the kinds of inferences that can be made efficiently from N DB. We would like
some inferences to be hard (e.g., inferring the original DB from N DB) and other inferences to be easy,
depending on the application (e.g., finding certain kinds of correlations in DB). However, in this paper,
1 Although indexing schemes could be developed to support truly efficient membership queries, our current emphasis is on
demonstrating the dichotomy between tractable and intractable queries.
2
we will focus only on the question of how easy it is to recover the original DB from N DB, a question we
address in Section 3.
Prefix algorithm
Let wi denote an i-bit prefix and Wi a set
of i-length bit patterns.
1.
i←0
2.
Set Wi to the empty set
3.
Set Wi+1 to every pattern not present in
DB’s wi+1 but with prefix in Wi
4.
for each pattern Vp in Wi+1 {
5.
Create a record using Vp as its prefix
and the remaining positions set to the
don’t care symbol.
6.
Add record to N DB.}
7.
Increment i by one
8.
Set Wi to every pattern in DB’s wi
9.
Return to step 3 as long as i < l. Figure 1: The Prefix algorithm outputs a negative database N DB of size O(l|DB|) representing the strings in U − DB. DB 0001 0100 1000 1011 U − DB 0000 0010 0011 0101 0110 0111 1001 1010 1100 1101 1110 1111 N DB 11** 001* 011* 0000 0101 1001 1010 c-keys 11** 0*1* *11* 00*0 *1*1 1*01 **10 RN DB 11** 0*1* 1110 *111 00*0 *1*1 0101 1*01 **10 *010 Figure 2: Column 1 gives an example DB, column 2 gives the corresponding U − DB, column 3 gives the corresponding N DB generated by the prefix algorithm, column 4 gives an example output of RN DB, and column 5 presents some possible c-keys extracted from N DB (see section 4).
Lemma 2.1.1. The prefix algorithm creates a database N DB that matches exactly those strings not in
DB.
Proof. Step three of the algorithm (Fig. 1) finds every prefix not present in DB that has not already been
inserted in N DB. It then appends every possible string with that prefix to N DB (step 5). If a DB pattern
is not present in window wi+1 and its prefix is not in wi then it must have been inserted in N DB before.
Step two initializes W0 so that the first iteration considers every pattern absent from DB.
Theorem 2.1.1. The negative data set (U − DB) can be represented using O(l|DB|) records.
3
Proof. For every window of size i there are at most |DB| “negative” records created and inserted in N DB
(steps 4–6). The number of windows is at most l (step 9) therefore, the number of negative records is
O(l|DB|).
The N DB produced by the prefix algorithm has some interesting properties. For example, each record
of N DB uniquely covers a subset of U − DB. This nonoverlapping property allows N DB to support more
powerful queries than simple membership. Questions like ”Are there any engineers in DB?” can be answered
by finding all records that match ’engineer’ in the corresponding field of N DB and simply counting whether
these records completely represent the subset of U that contains the engineers. An example DB, U − DB
and the N DB produced by the prefix algorithm is given in Fig. 2.
3
Reversibility
In section 2.1 we presented an algorithm for generating N DB that easily demonstrates the feasibility of a
negative representation. In what follows we turn our attention to the goal of making DB hard to reconstruct.
First we establish that the representation is potentially difficult to reverse, and then we present an algorithm
which indeed produces hard to reverse instances.
Reconstruction of DB from N DB is N P-hard in the following sense2 .
Definition 3.0.1. Self Recognition (SR):
INPUT: U − DB represented by a collection N DB of length l bit strings, such that each string may contain
any number of * symbols, and a candidate self set DB.
QUESTION: Does N DB represent the self set DB?
We establish SR is N P-hard. Note that N DB represents an arbitrary set U − DB, and we do not specify
how it was obtained. First we establish the N P-completeness of the following problem.
Definition 3.0.2. Non-empty Self Recognition (NESR):
INPUT: A set U −DB of binary strings represented by a collection N DB of length l strings over the alphabet
{0, 1, ∗}.
QUESTION: Is DB nonempty? That is, is there some string in U = {0, 1}l not matched by N DB?
Theorem 3.0.2. NESR is N P-complete.
Proof. NESR is clearly in N P. (If we guess a string, it is easy to verify that it is not matched by comparing
it against every record in N DB.)
The N P-completeness of NESR is established by transformation from 3-SAT. Start with instance I of 3SAT. Let X be the set of variables {xi }, and suppose l is the number of variables. The constructed instance
of NESR will be over length l strings. Each clause {Li , Lj , Lk } in I (Li is a literal, which is either xi or
xi complement) creates a length l string in N DB as follows. All positions other than i, j, or k contain ∗.
Position i contains 0 if Li is xi and contains 1 if Li is x̄i (complemented xi ). A similar construction is used
for the other two literals Lj and Lk in this clause.
Claim: There exists a truth assignment satisfying I if and only if there exists a string in U = {0, 1}l not
matched by N DB. In the following, if A is a truth assignment to the variables in X, S(A) is the string in
U obtained by setting the ith bit to 1 if A assigns xi = T and the ith bit to 0 if A assigns xi = F .
We have:
A satisfies I
⇔ for every clause Cq = {Li , Lj , Lk }, at least one
literal is satisfied
⇔ S(A) fails to match at least one of the bits
i, j, k of the q th member of N DB
2 For
historical reasons we sometimes refer to DB as Self and U − DB as Nonself.
4
(generated from Cq ), because uncomplemented literal
Li generates 0 in the ith position and
complemented Li generates 1 in ith position, and
similarly for Lj , Lk )
⇔ S(A) is in DB.
Corollary 3.0.1. NESR is N P-complete even if every record of N DB contains exactly three defined positions.
Proof. Our transformation always produces such an instance of NESR.
Corollary 3.0.2. Empty Self Recognition (ESR, the complement of NESR, answers YES if and only if
N DB represents the empty set) is N P-hard.
Proof. Trivial Turing transformation from NESR.
Theorem 3.0.3. Self Recognition (SR, defined above) is N P-hard.
Proof. We have established this to be the case even when the candidate self set DB is empty, and even when
every member of N DB contains exactly three defined positions.
4
The Randomize N DB Algorithm
The prefix algorithm presented in Section 2.1 is simple and demonstrates that a compact negative representation N DB can be obtained from DB. Although we have demonstrated in Section 3 that the general
problem of reversing a given set N DB to obtain DB is N P-hard, using the simple prefix algorithm to obtain
N DB from DB raises two concerns regarding privacy: (a) The prefix algorithm produces only an easy subset
of possible N DB instances, and (b) If the action of the prefix algorithm (or any algorithm) that produces
N DB from DB could be reproduced by an adversary, then the adversary could easily decide for a given
N DB and candidate DB whether N DB represents U − DB. (The two concerns are, of course, related, for
if an algorithm were capable of producing only one N DB for each DB it is given as input, the image of the
algorithm could not define an N P-hard set of instances of NESR.) In this section, we present a randomized
algorithm (Fig. 3), the Randomize N DB algorithm (RN DB for short), which addresses both of these concerns. The prefix algorithm is modified by introducing a sequence of random choices that enlarges the set of
instances of N DB it can produce, so that the reversibility of the problem instances in the algorithm’s image
defines an N P-hard problem. Further, since the execution of the algorithm is randomized, re-application of
the algorithm by an adversary requires reproducing the algorithm’s random sequence of choices (see example
in Fig. 2).
Section 3 presents a transformation from 3-SAT to N DB, and in what follows we will use the formalisms
interchangeably. In particular, DB and sets of assignments will be used interchangeably, N DB and formula
φ will be used interchangeably, and the output of the algorithms to be presented in this section can be viewed
either as strings in N DB or clauses in φ.
Definition 4.0.3. A c-key is bit pattern not present in DB with no extraneous bits: A c-key defines
a minimal pattern in that the removal of any bit yields a pattern in DB (see figure 2). A c̄-key is the
complement of a c-key.
Definition 4.0.4. A c-clause is a pattern composed of a c̄-key plus at most two additional specified bit
positions.
Theorem 4.0.4. Let DB be a set of assignments and φ a CN F formula. φ is satisfied by every x ∈ DB iff
every clause Cq in φ contains a c̄-key with respect to DB.
5
Proof. Suppose clause Cq of φ contains a c̄-key. Then, by definition 4.0.3, no x ∈ DB contains the complement pattern of c̄-key. Thus each x ∈ DB contains at least one bit appearing in c̄-key, hence satisfying the
corresponding literal of this bit, thus satisfying Cq .
Now suppose each x ∈ DB satisfies each clause of φ (that is, each x is a satisfying truth assignment for
φ). Suppose to the contrary, that some clause Cq does not contain a c̄-key. Then, the complement pattern
of c̄-key appears in DB, and in particular in at least one x ∈ DB. But then x contains no bit appearing in
c̄-key, thus failing to satisfy each of the corresponding literals in Cq . Hence, we have a contradiction, and it
must be that every clau …
Purchase answer to see full
attachment

How it works

1. Paste your instructions in the instructions box. You can also attach an instructions file
2. Select the writer category, deadline, education level and review the instructions 
3. Make a payment for the order to be assignment to a writer
4.  Download the paper after the writer uploads it 

Will the writer plagiarize my essay?

You will get a plagiarism-free paper and you can get an originality report upon request.

Is this service safe?

All the personal information is confidential and we have 100% safe payment methods. We also guarantee good grades