52 research outputs found
The zero-error randomized query complexity of the pointer function
The pointer function of G{\"{o}}{\"{o}}s, Pitassi and Watson
\cite{DBLP:journals/eccc/GoosP015a} and its variants have recently been used to
prove separation results among various measures of complexity such as
deterministic, randomized and quantum query complexities, exact and approximate
polynomial degrees, etc. In particular, the widest possible (quadratic)
separations between deterministic and zero-error randomized query complexity,
as well as between bounded-error and zero-error randomized query complexity,
have been obtained by considering {\em
variants}~\cite{DBLP:journals/corr/AmbainisBBL15} of this pointer function.
However, as was pointed out in \cite{DBLP:journals/corr/AmbainisBBL15}, the
precise zero-error complexity of the original pointer function was not known.
We show a lower bound of on the zero-error
randomized query complexity of the pointer function on bits;
since an upper bound is already known
\cite{DBLP:conf/fsttcs/MukhopadhyayS15}, our lower bound is optimal up to a
factor of \polylog\, n
Towards Better Separation between Deterministic and Randomized Query Complexity
We show that there exists a Boolean function which observes the following
separations among deterministic query complexity , randomized zero
error query complexity and randomized one-sided error query
complexity : and
. This refutes the conjecture made by Saks
and Wigderson that for any Boolean function ,
. This also shows widest separation between
and for any Boolean function. The function was defined by
G{\"{o}}{\"{o}}s, Pitassi and Watson who studied it for showing a separation
between deterministic decision tree complexity and unambiguous
non-deterministic decision tree complexity. Independently of us, Ambainis et al
proved that different variants of the function certify optimal (quadratic)
separation between and , and polynomial separation between
and . Viewed as separation results, our results are subsumed
by those of Ambainis et al. However, while the functions considerd in the work
of Ambainis et al are different variants of , we work with the original
function itself.Comment: Reference adde
Efficient data intensive secure computation : fictional or real
Secure computation has the potential to completely reshape the cybersecruity landscape, but this will happen only if we can make it practical. Despite significant improvements recently, secure computation is still orders of magnitude slower than computation in the clear. Even with the latest technology, running the killer apps, which are often data intensive, in secure computation is still a mission impossible. In this paper, I present two approaches that could lead to practical data intensive secure computation. The first approach is by designing data structures. Traditionally, data structures have been widely used in computer science to improve performance of computation. However, in secure computation they have been largely overlooked in the past. I will show that data structures could be effective performance boosters in secure computation. Another approach is by using fully homomorphic encryption (FHE). A common belief is that FHE is too inefficient to have any practical applications for the time being. Contrary to this common belief, I will show that in some cases FHE can actually lead to very efficient secure computation protocols. This is due to the high degree of internal parallelism in recent FHE schemes. The two approaches are explained with Private Set Intersection (PSI) as an example. I will also show the performance figures measured from prototype implementations
PrivacyFL: A simulator for privacy-preserving and secure federated learning
Federated learning is a technique that enables distributed clients to
collaboratively learn a shared machine learning model while keeping their
training data localized. This reduces data privacy risks, however, privacy
concerns still exist since it is possible to leak information about the
training dataset from the trained model's weights or parameters. Setting up a
federated learning environment, especially with security and privacy
guarantees, is a time-consuming process with numerous configurations and
parameters that can be manipulated. In order to help clients ensure that
collaboration is feasible and to check that it improves their model accuracy, a
real-world simulator for privacy-preserving and secure federated learning is
required. In this paper, we introduce PrivacyFL, which is an extensible, easily
configurable and scalable simulator for federated learning environments. Its
key features include latency simulation, robustness to client departure,
support for both centralized and decentralized learning, and configurable
privacy and security mechanisms based on differential privacy and secure
multiparty computation. In this paper, we motivate our research, describe the
architecture of the simulator and associated protocols, and discuss its
evaluation in numerous scenarios that highlight its wide range of functionality
and its advantages. Our paper addresses a significant real-world problem:
checking the feasibility of participating in a federated learning environment
under a variety of circumstances. It also has a strong practical impact because
organizations such as hospitals, banks, and research institutes, which have
large amounts of sensitive data and would like to collaborate, would greatly
benefit from having a system that enables them to do so in a privacy-preserving
and secure manner
Sign-Rank Can Increase Under Intersection
The communication class UPP^{cc} is a communication analog of the Turing Machine complexity class PP. It is characterized by a matrix-analytic complexity measure called sign-rank (also called dimension complexity), and is essentially the most powerful communication class against which we know how to prove lower bounds.
For a communication problem f, let f wedge f denote the function that evaluates f on two disjoint inputs and outputs the AND of the results. We exhibit a communication problem f with UPP^{cc}(f)= O(log n), and UPP^{cc}(f wedge f) = Theta(log^2 n). This is the first result showing that UPP communication complexity can increase by more than a constant factor under intersection. We view this as a first step toward showing that UPP^{cc}, the class of problems with polylogarithmic-cost UPP communication protocols, is not closed under intersection.
Our result shows that the function class consisting of intersections of two majorities on n bits has dimension complexity n^{Omega(log n)}. This matches an upper bound of (Klivans, O\u27Donnell, and Servedio, FOCS 2002), who used it to give a quasipolynomial time algorithm for PAC learning intersections of polylogarithmically many majorities. Hence, fundamentally new techniques will be needed to learn this class of functions in polynomial time
- …