# News for August 2021

This month saw four papers. One on group testing, another on distribution testing, yet another which makes progress on testing problems on decision trees and the last one on graph property testing. Without further ado, let’s dive in.

Group Testing with Non-identical Infection Probabilities by Mustafa Doger, Sennur Ulukus (arXiv) Consider the classic group testing problem. Here the setup is the following. You are given a bunch of individuals from a population $$\mathcal{P}$$. You have an infection vector which records the infection status of each individual in the population where the $$i$$-th individual is infected with probability $$p_i$$. You want to recover all the infected individuals. You are allowed to group individuals together and you can test the entire group in a single shot. If the group tests negative, you are happy all the tested individuals are off the hook. Otherwise, if the group tests positive, you need more tests for further classification. This paper proposes a greedy way to build pools of individuals you would test. The pools are built adaptively: as in future pools are built using the knowledge of how the preceding tests fared. The key result in the paper upperbounds the number of tests performed in terms of the entropy of the infection vector.

Uniformity Testing in the Shuffle Model: Simpler, Better, Faster by Clément L. Canonne, Hongyi Lyu (arXiv) Differentially private distribution testing as a research area has been gathering momentum steadily over the last few years. If you read our last month’s post, you might recall there are a wide variety of models of DP each corresponding to a different “threat model”. The most stringent among the most explored models is the “local model”, the least stringent being the “central model” and there is an intermediate threat model, the so called “shuffle model“. This paper simplifies the analysis of uniformity testing algorithm under the shuffle model and presents an algorithm with sample complexity $$O(k^{3/4})$$ for testing uniformity over a support of size $$[k]$$.

On Learning and Testing Decision Tree by Nader H. Bshouty, Catherine A. Haddad-Zaknoon (arXiv) In our December 2020 post, we covered a result of Blanc et al., which proves the following: Suppose you are given a boolean function $$f$$ and the property $$\mathcal{P}$$ of size-$$s$$ decision trees. The result of Blanc et al gives you a function $$g \in \mathcal{P}$$ with $$dist(f,g) = O(dist (f, \mathcal{P}))$$ where $$g \in$$ is guaranteed to have decision tree complexity $$s^{O(\log^2 s)}$$. This result implies a bi-criteria tester for the following property: is $$f \in \mathcal{P}$$ or is $$f$$ $$\varepsilon$$-far from having decision tree complexity $$\phi(s) = s^{O(\log^3 s)}$$. The current paper improves this result by presenting a property tester with $$\phi(s) = s^{O(\log^2 s)}$$.

The complexity of testing all properties of planar graphs, and the role of isomorphism by Sabyasachi Basu, Akash Kumar, C. Seshadhri (arXiv) (Disclaimer: I am one of the authors of this paper). This paper presents a result that I, in my biased opinion, find interesting. So, here is the setup. You are given a bounded degree planar graph. And I cook up some God-forsaken property and ask you to test it. Turns out, no matter how devilishly I cooked up the property, you can test in with $$\exp(O(\varepsilon^{-2}))$$ queries. The nice happenstance is that you also have a matching lower bound of $$\exp(\Omega(\varepsilon^{-2}))$$ queries! And interestingly, this lower bound is witnessed by the very natural property of testing isomorphism to a fixed graph which means that isomorphism is the hardest property of planar graphs.

# Workshop on Algorithms for Large Data: We found WALD(O), and so can you!

Ainesh Bakshi, Rajesh Jayaram, and Samson Zhou are organizing a 3-day Workshop on Algorithms for Large Data (nicely abbreviated as WALD(O), the O standing for Online), featuring many talks which should be of interest to the readers of this blog, as well as an open problems and a poster sessions, and a junior/senior lunch. As the organizers describe it:

This workshop aims to foster collaborations between researchers across multiple disciplines through a set of central questions and techniques for algorithm design for large data. We will focus on topics such as sublinear algorithms, randomized numerical linear algebra, streaming and sketching, and learning and testing.

The workshop will take place on August 23 — August 25 (ET). Attendance is free, but registration is required by August 20th. More details at https://waldo2021.github.io/

# New for July 2021

This month saw three papers appear online, together covering a rather broad range of topics: testing of regular languages, distribution testing under differential privacy, and local testability from high-dimensional expanders. Let’s dive in!

Property Testing of Regular Languages with Applications to Streaming Property Testing of Visibly Pushdown Languages, by Gabriel Bathie and Tatiana Starikovskaya (paper). Let $$L\in \Sigma^\ast$$ be a regular language recognized by an automation with $$m$$ states and $$k$$ connected components: given as input a word $$u\in \Sigma^n$$, what is the query complexity to test membership to $$L$$ in Hamming distance? Edit distance? Or, more generally, weighted edit distance, where each letter of the word $$u$$ comes with a weight? In this paper, the authors focus on non-adaptive, one-sided errors testing algorithms, for which they show an upper bound of $$q=O(k m \log(m/\varepsilon)/\varepsilon)$$ queries (with running time $$O(m^2 q)$$), which they complement by a query complexity lower bound of $$\Omega(\log(1/\varepsilon)/\epsilon)$$, thus matching the upper bound for languages recognized by constant-size automata. The guarantee for the upper bound is with respected to weighted edit distance, and thus implies the same upper bound for testing with respect to Hamming distance.
To conclude, the authors use an existing connection to streaming property testing to obtain new algorithms for property testing of visibly pushdown languages (VPL) in the streaming model, along with a new lower bound in that model.

High dimensional expansion implies amplified local testability, by Tali Kaufman and Izhar Oppenheim (arXiv). This paper sets out to show that codes that arise from high-dimensional expanders are locally testable (membership to the code can be tested using very few queries). To do so, the authors define a new notion of high-dimensional expanding system (HDE system), as well as that of amplified local testability, a stronger notion than local testability; they then prove that a code based on a HDE system satisfies this stronger notion. Moreover, they show that many well-known families of codes are, in fact, HDE system codes, and therefore satisfy this stronger notion of local testability as well.

Finally, a survey on differential privacy, with a foray into distribution testing:

Differential Privacy in the Shuffle Model: A Survey of Separations, by Albert Cheu (arXiv). If you are familiar with differential privacy (DP), you may recall that there are several notions of DP, each meant to address a different “threat model” (depending on whom you trust with your data). Shuffle DP is one of them, intermediate between “central” DP and the more stringent “local” DP. Long story short: with shuffle DP, the tradeoff between privacy and accuracy can be strictly in-between what’s achievable in central and local DP, and that’s the case for one of the usual suspects of distribution testing, uniformity testing (“I want to test if the data uniformly distributed, but now, with privacy of that data in mind”). The survey discusses what is known about this in Sections 3.3 and 6, and what the implications are; but there are quite a few questions left unanswered… Long story short: a very good introduction to shuffle privacy, and to open problems in that area!

# News for June 2021

A quieter month after last month’s bonanza. One (applied!) paper on distribution testing, a paper on tolerant distribution testing, and a compendium of open problems. (Ed: alas, I missed the paper on tolerant distribution testing, authored by one of our editors. Sorry, Clément!)

Learning-based Support Estimation in Sublinear Time by Talya Eden, Piotr Indyk, Shyam Narayanan, Ronitt Rubinfeld, Sandeep Silwal, and Tal Wagner (arXiv). A classic problem in distribution testing is that of estimating the support size $$n$$ of an unknown distribution $$\mathcal{D}$$. (Assume that all elements in the support have probability at least $$1/n$$.) A fundamental result of Valiant-Valiant (2011) proves that the sample complexity of this problem is $$\Theta(n/\log n)$$. A line of work has emerged in trying to reduce this complexity, with additional sources of information. Canonne-Rubinfeld (2014) showed that, if one can query the exact probabilities of elements, then the complexity can be made independent of $$n$$. This paper studies a robust version of this assumption: suppose, we can get constant factor approximations to the probabilities. Then, the main result is that we can get a query complexity of $$n^{1-1/\log(\varepsilon^{-1})} \ll n/\log n$$ (where the constant $$\varepsilon$$ denotes the additive approximation to the support size). This paper also does empirical experiments to show that the new algorithm is indeed better in practice. Moreover, it shows that existing methods degraded rapidly with poorer probability estimates, while the new algorithm maintains its accuracy even with such estimates.

The Price of Tolerance in Distribution Testing by Clément L. Canonne, Ayush Jain, Gautam Kamath, and Jerry Li (arXiv). While we have seen many results in distribution testing, the subject of tolerance is one that hasn’t received as much attention. Consider the problem of testing if unknown distribution $$\mathcal{p}$$ (over domain $$[n]$$) is the same as known distribution $$\mathcal{q}$$. We wish to distinguish $$\varepsilon_1$$-close from $$\varepsilon_2$$-far, under total variation distance. When $$\varepsilon_1$$ is zero, this is the standard property testing setting, and classic results yield $$\Theta(\sqrt{n})$$ sample complexity. If $$\varepsilon_1 = \varepsilon_2/2$$, then we are looking for a constant factor approximation to the distance. And the complexity is $$\Theta(n/\log n)$$. Surprisingly, nothing was known in better. Until this paper, that is. The main result gives a complete characterization of sample complexity (up to log factors), for all values of $$\varepsilon_1, \varepsilon_2$$. Remarkably, the sample complexity has an additive term $$(n/\log n) \cdot (\varepsilon_1/\varepsilon^2_2)$$. Thus, when $$\varepsilon_1 > \sqrt{\varepsilon_2}$$, the sample complexity is $$\Theta(n/\log n)$$. When $$\varepsilon_1$$ is smaller, the main result gives a smooth dependence on the sample complexity. One the main challenges is that existing results use two very different techniques for the property testing vs constant-factor approximation regimes. The former uses simpler $$\ell_2$$-statistics (e.g. collision counting), while the latter is based on polynomial approximations (estimating moments). The upper bound in this paper shows that simpler statistics based on just the first two moments suffice to getting results for all regimes of $$\varepsilon_1, \varepsilon_2$$.

Open Problems in Property Testing of Graphs by Oded Goldreich (ECCC). As the title clearly states, this is a survey covering a number of open problems in graph property testing. The broad division is based on the query model: dense graphs, bounded degree graphs, and general graphs. A reader will see statements of various classic open problems, such as the complexity of testing triangle freeness for dense graphs and characterizing properties that can be tested in $$poly(\varepsilon^{-1})$$ queries. Arguably, there are more open problems (and fewer results) for testing in bounded degree graphs, where we lack broad characterizations of testable properties. An important, though less famous (?), open problem is that of the complexity of testing isomorphism. It would appear that the setting of general graphs, where we know the least, may be the next frontier for graph property testing. A problem that really caught my eye: can we transform testers that work for bounded degree graphs into those that work for bounded arboricity graphs? The latter is a generalization of bounded degree that has appeared in a number of recent results on sublinear graph algorithms.

# Looking back at WOLA’21: Videos available

The fifth Workshop on Local Algorithms (WOLA’21) took place earlier this month, and the recordings of the invited talks are now available on YouTube. If you missed the workshop, or want to refresh your memory, here are the recordings (ordered by the workshop schedule):

Thanks again to the speakers and organizers, and looking forward to WOLA’22!

# News for May 2021

We hope you are all staying safe. With massive vaccination programs across the globe we hope you and your loved ones are getting back to what used to be normal. With that out of the way, let us circle back to Property Testing. This month was less sleepy as compared to the two preceding months and we saw six papers in total (two of them explore problems in quantum property testing). Without further ado, let us take a deeper dive.

GSF-locality is not sufficient for proximity-oblivious testing, by Isolde Adler, Noleen Kohler, Pan Peng (arXiv) The notion of proximity oblivious testers was made explicit in the seminal work of Goldreich and Ron in 2009 [GR09]. A proximity oblivious tester for a graph property is a constant query tester that rejects a graph with probability that monotonically increases with distance to the property. (Edit: Correction) A property is called proximity oblivious testable (or PO testable) if it has a one sided proximity oblivious tester. [GR09] gave a characterization of which properties $$\Pi$$ are PO testable in the bounded degree model if and only if it is a “local” property of some kind which satisfies a certain non propagation condition. [GR09] conjectured that all such “local” properties satisfy this non propagation condition. This paper refutes the above conjecture from [GR09].

Coming up next. More action on triangle freeness.

Testing Triangle Freeness in the General Model in Graphs with Arboricity $$O(\sqrt n)$$, by Reut Levi (arXiv) PTReview readers are likely to be aware that triangle freeness has been a rich source of problems for developing new sublinear time algorithms. This paper considers the classic problem of testing triangle freeness in general graphs. In the dense case, algorithms with running time depending only on $$\varepsilon$$ are known thanks to the work of Alon, Fischer, Krivelevich and Szegedy. In the bounded degree case, Goldreich and Ron gave testers with query complexity $$O(1/\varepsilon)$$. This paper explores the problem in general graph case and proves an upper bound of $$O(\Gamma/d_{avg} + \Gamma)$$ where $$\Gamma$$ is the arboricity of the graph. The author also shows that this upperbound is tight for graphs with arboricity at most $$O(\sqrt n)$$. Curiously enough, the algorithm does not take arboricity of the graph as an input and yet $$\Gamma$$ (the arboricity) shows up in the upper and lower bounds.

Testing Dynamic Environments: Back to Basics, by Yonatan Nakar and Dana Ron (arXiv) Goldreich and Ron introduced the problem of testing “dynamic environments” in 2014. Here is the setup for this problem. You are given an environment that evolves according to a local rule. Your goal is to query some of the states in the system at some point of time and determine if the system is evolving according to some fixed rule or is far from it. In this paper, the authors consider environments defined by elementary cellular automata which evolve according to threshold rules as one of the first steps towards understanding what makes a dynamic environment tested efficiently. The main result proves the following: if your local rules satisfy some conditions, you can use a meta algorithm with query complexity $$poly(1/\varepsilon)$$ which is non adaptive and has one sided error. And all the threshold rules indeed satisfy these conditions which means they can be tested efficiently.

Identity testing under label mismatch, by Clement Canonne and Karl Wimmer (arXiv) This paper considers a classic problem distribution testing with the following twist. Let $$q$$ denote a distribution supported on $$[n]$$. You are given access to samples from another distribution $$p$$ where $$p = q \circ \pi$$ where $$\pi$$ is some unknown permutation. Thus, I relabel the data and I give you access to samples from the relabeled dataset. Under this promise, note that identity testing becomes a trivial problem if $$q$$ is known to be uniform over $$[n]$$. The authors develop algorithms for testing and tolerant testing of distributions under this additional promise of $$p$$ being a permutation of some known distribution $$q$$. The main result shows as exponential gap between the sample complexity of testing and tolerant testing under this promise. In particular, identity testing under the promise of permutation has sample complexity $$\Theta(\log^2 n)$$ whereas tolerant identity testing under this promise has sample complexity $$\Theta(n^{1-o(1)})$$.

Testing symmetry on quantum computers, by Margarite L. LaBorde and Mark M. Wilde (arXiv) This paper develops algorithms which test symmetries of a quantum states and changes generated by quantum circuits. These tests additionally also quantify how symmetric these states (or channels) are. For testing what are called “Bose states” the paper presents efficient algorithms. The tests for other kinds of symmetry presented in the paper rely on some aid from a quantum prover.

Quantum proofs of proximity, by Marcel Dall’Agnol, Tom Gur, Subhayan Roy Moulik, Justin Thaler (ECCC) The sublinear time (quantum) computation model has been gathering momentum steadily over the past several years. This paper seeks to understand the power of $${\sf QMA}$$ proofs of proximity for property testing (recall $${\sf QMA}$$ is the quantum analogue of $${\sf NP}$$). On the algorithmic front, the paper develops sufficient conditions for properties to admit efficient $${\sf QMA}$$ proofs of proximity. On the complexity front, the paper demonstrates a property which admits an efficient $${\sf QMA}$$ proof but does not admit a $${\sf MA}$$ or an interactive proof of proximity.

# Announcing WOLA’21 (Workshop on Local Algorithms)

The fifth WOLA (Workshop on Local Algorithms) will be virtual, and take place June 14-15. Registration is free, but required: please fill this form by June 10th to attend.

Local algorithms — that is, algorithms that compute and make decisions on parts of the output considering only a portion of the input — have been studied in a number of areas in theoretical computer science and mathematics. Some of the related areas include sublinear-time algorithms, distributed algorithms, streaming algorithms, (massively) parallel algorithms, inference in large networks, and graphical models. These communities have similar goals but a variety of approaches, techniques, and methods. This workshop is aimed at fostering dialogue and cross-pollination of ideas between the various communities.

This year, the workshop will include:

• A poster session: Please submit your poster proposal (title and abstract) at by May 26th. Everyone is invited to contribute. This session will take place on gather.town.
• Invited long talks: the tentative schedule is available, and features talks by James Aspnes, Jelani Nelson, Elaine Shi, Christian Sohler, Uri Stemmer, and Mary Wootters.
• Junior-Senior social meetings
• An AMA (Ask Me Anything) session, moderated by Merav Parter
• A Slack channel
• An Open Problems session

The Program Committee of WOLA 2021 is comprised of:

• Venkatesan Guruswami (CMU)
• Elchanan Mossel (MIT)
• Merav Parter (Weizmann Institute of Science)
• Sofya Raskhodnikova (chair) (Boston University)
• Gregory Valiant (Stanford)

and the organizing committee:

• Sebastian Brandt (ETH)
• Yannic Maus (Technion)
• Slobodan Mitrović (MIT)

For more detail, see the website; to stay up to date with the latest announcements concerning WOLA, join our mailing list!

# News for April 2021

A somewhat “sublinear” month of April, as far as property testing is concerned, with only one paper. (We may have missed some; if so, please let us know in the comments!)

Graph Streaming Lower Bounds for Parameter Estimation and Property Testing via a Streaming XOR Lemma, by Sepehr Assadi and Vishvajeet N (arXiv). This paper establishes space vs. pass trade-offs lower bounds for streaming algorithms, for a variety of graph tasks: that is, of the sort “any $$m$$-pass-streaming algorithm for task $$\mathcal{T}$$ must use memory at least $$f(m)$$.” The tasks considered include graph property estimation (size of the maximum matching, of the max cut, of the weight of the MST) and property testing for sparse graphs (connectivity, bipartiteness, and cycle-freeness). The authors obtained exponentially improved lower bounds for those, via reductions to a relatively standard problem, (noisy) gap cycle counting, for which they establish their main lower bound. As a key component of their proof, they prove a general direct product result (XOR lemma) for the streaming setting, showing that the advantage for solving the XOR of $$\ell$$ copies of a streaming predicate $$f$$ decreases exponentially with $$\ell$$.

# News for March 2021

A somewhat quieter month by recent standards. Three Two papers: graph property testing and quantum distribution testing. (Ed: The distribution testing paper was a revision of a paper we already covered in Sept 2020.)

Robust Self-Ordering versus Local Self-Ordering by Oded Goldreich (ECCC). In Nov 2020, we covered a paper that uses a tool called self-ordered graphs, that transferred bit string function lower bounds to graph property testing. Consider a labeled graph. A graph is self-ordered if its automorphism group only contains the identity element (it has no non-trivial isomorphisms). A graph is robustly self-ordered, if every permutation of the vertices leads to a (labeled) graph that is sufficiently “far” according to edit distance. Given a self-ordered graph $$G$$, a local self-ordering procedure is the following. Given access to a copy $$G’$$ of $$G$$ and a vertex $$v \in V(G’)$$, this procedure determines the (unique) vertex in $$V(G)$$ that corresponds to $$v$$ with sublinear queries to $$G$$. In other words, it can locally “label” the graph. Intuitively, one would think that more robustly self-ordered graphs will be easier to locally label. This paper studies the relation between robust and local self-ordering. Curiously, this paper refutes the above intuition for bounded-degree graphs, and (weakly) confirms it for dense graphs. Roughly speaking, there are bounded degree graphs that are highly robustly self-ordered, for which any local self-ordering procedure requires $$\omega(\sqrt{n})$$ queries. Moreover, there are bounded degree graphs with $$O(\log n)$$-query local self-ordering procedures, yet are not robustly self-ordered even for weak parameters. For dense graphs, the existence of fast non-adaptive local self-ordering procedures implies robust self-ordering.

Testing identity of collections of quantum states: sample complexity analysis by Marco Fanizza, Raffaele Salvia, and Vittorio Giovannetti (arXiv). This paper takes identity testing to the quantum setting. One should think of a $$d$$-dimensional quantum state as a $$d \times d$$ density matrix (with some special properties). To learn the state entirely up to error $$\varepsilon$$ would require $$O(\varepsilon^{-2} d^2)$$ samples/measurements. A recent result of Badescu-O’Donnell-Wright proves that identity testing to a known state can be done significantly faster using $$O(\varepsilon^{-2} d)$$ measurements. This paper takes this result a step further by consider a set of $$N$$ quantum states. A “sample” is like a classical sample, where one gets a sample from a distribution of quantum states. The YES (“uniform”) case is when all the states are identical. The NO (“far from uniform”) case is when they are “far” from being the same state. This paper proves that $$O(\varepsilon^{-2}\sqrt{N}d)$$ samples suffices for distinguishing these cases.

# News for February 2021

We got quite some action last month. We saw five papers. A lot of action in graph world and some action in quantum property testing which we hope you will find appetizing. Also included is a result on sampling uniformly random graphlets.

Testing Hamiltonicity (and other problems) in Minor-Free Graphs, by Reut Levi and Nadav Shoshan (arXiv). Graph Property Testing has been explored pretty well for dense graphs (and reasonably well for bounded degree graphs). However, testing properties in the general case still remains an elusive goal. This paper makes contributions in this direction and as a first result it gives an algorithm for testing Hamiltonicity in minor free graphs (with two sided error) with running time $$poly(1/\varepsilon)$$. Let me begin by pointing out that Hamiltonicity is an irksome property to test in the following senses.

• It is neither monotone nor additive. So the partition oracle based algorithms do not immediately imply a tester (with running time depending only on $$\varepsilon$$ for Hamiltonicity. This annoyance bugs you even in the bounded degree case.
• Czumaj and Sohler characterized what graph properties are testable with one-sided error in general planar graphs. In particular, they show a property of general planar graphs is testable iff this property can be reduced to testing for a finite family of finite forbidden subgraphs. Again, Hamiltonicity does not budge to this result.
• There are (concurrent) results by Goldreich and Adler-Kohler which show that with one-sided error, Hamiltonicity cannot be tested with $$o(n)$$ queries.

The paper shows that distance to Hamiltonicity can be exactly captured in terms of a certain combinatorial parameter. Thereafter, the paper tries to estimate this parameter after cleaning up the graph a little. This allows them to estimate the distance to Hamiltonicity and thus also implies a tolerant tester (restricted to mino-free graphs).

Testing properties of signed graphs, by Florian Adriaens, Simon Apers (arXiv). Suppose I give you a graph $$G=(V,E)$$ where all edges come with a label: which is either “positive” or “negative”. Such signed graphs are used to model various scientific phenomena. Eg, you can use these to model interactions between individuals in social networks into two categories like friendly or antagonistic.

This paper considers property testing problems on signed graphs. The notion of farness from the property extends naturally to these graphs (both in the dense graph model and the bounded degree model). The paper contains explores three problems in both of these models: signed triangle freeness, balance and clusterability. Below I will zoom into the tester for clusterability in the bounded degree setting developed In the paper. A signed graph is considered clusterable if you can partition the vertex set into some number of components such that the edges within any component are all positive and the edges running across components are all negative.

The paper exploits a forbidden subgraph characterization of clusterability which shows that any cycle with exactly one negative edge is a certificate of non-clusterability of $$G$$. The tester runs multiple random walks from a handful of start vertices to search for these “bad cycles” by building up on ideas in the seminal work of Goldreich and Ron for testing bipariteness. The authors put all of these ideas together and give a $$\widetilde{O}(\sqrt n)$$ time one-sided tester for clusterability in signed graphs.

Local Access to Random Walks, by Amartya Shankha Biswas, Edward Pyne, Ronitt Rubinfeld (arXiv). Suppose I give you a gigantic graph (with bounded degree) which does not fit in your main memory and I want you to solve some computational problem which requires you to solve longish random walks of length $$t$$. And lots of them. It would be convenient to not spend $$\Omega(t)$$ units of time performing every single walk. Perhaps it would work just as well for you to have an oracle which provides query access to a $$Position(G,s,t)$$ oracle which returns the position of a walk from $$s$$ at time $$t$$ of your choice. Of course, you would want the sequence of vertices returned to behave consistently with some actual random walk sampled from the distribution of random walks starting at $$s$$. Question is: Can I build you this primitive? This paper answers this question in affirmative  and shows that for graphs with spectral gap $$\Delta$$, this can be achieved with running time $$\widetilde{O}(\sqrt n/\Delta)$$ per query. And you get the guarantee that the joint distribution of the vertices you return at queried times is $$1/poly(n)$$ close to the uniform distribution over such walks in $$\ell_1$$.  Thus, for a random $$d$$-regular graph, you get running times of the order $$\widetilde{O}(\sqrt n)$$ per query. The authors also show tightness of this result by showing to get subconstant error in $$\ell_1$$, you necessarily need $$\Omega(\sqrt n/\log n)$$ queries in expectation.

Efficient and near-optimal algorithms for sampling connected subgraphs, by Marco Bressan (arXiv). As the title suggests, this paper considers efficient algorithms for sampling a uniformly random $$k$$-graphlet from a given graph $$G$$ (for $$k \geq 3$$). Recall, a $$k$$-graphlet refers to a collection of $$k$$-vertices which induce a connected graph in $$G$$. The algorithm considered in the paper is pretty simple. You just define a Markov Chain $$\mathcal{G}_k$$ with all $$k$$-graphlets as its state space. Two states in $$\mathcal{G}_k$$ are adjacent iff their intersection is a $$(k-1)$$-graphlet. To obtain a uniformly random sample, a classical idea is to just run this Markov Chain and obtain an $$\varepsilon$$-uniform sample. However, the gap between upper and lower bounds on the mixing time of this walk is of the order $$\rho^{k-1}$$ where $$\rho = \Delta/\delta$$ (that is the ratio of maximum and minimum degrees to the power $$k-1$$). The paper closes this gap up to logarithmic factors and shows that the mixing time of the walk is at most $$t_{mix}(G) \rho^{k-1} \log(n/\varepsilon)$$. It also proves an almost matching lower bound. Further, the paper also presents an algorithm with event better running time to return an almost uniform $$k$$-graphlet. This exploits a previous observation: sampling a uniformly random $$k$$-graphlet is equivalent to sampling a uniformly random edge in $$\mathcal{G}_{k-1}$$. The paper then proves a lemma which upperbounds the relaxation time of walks in $$\mathcal{G}_k$$ to walks in $$\mathcal{G}_{k-1}$$. And then you upperbound the mixing time in terms of the relaxation time to get an improved expected running time of the order $$O(t_{mix}(G) \cdot \rho^{k-2} \cdot \log(n/\varepsilon)$$.

Toward Instance-Optimal State Certification With Incoherent Measurements, by Sitan Chen, Jerry Li, Ryan O’Donnell (arXiv). The problem of quantum state certification has gathered interest over the last few years. Here is the setup: you are given a quantum state $$\sigma \in \mathbb{C}^{d \times d}$$ and you are also given $$N$$ copies of an unknown state $$\rho$$. You want to distinguish between the following two cases: Does $$\rho = \sigma$$ or is $$\sigma$$ at least $$\varepsilon$$-far from $$\rho$$ in trace norm? Badescu et al showed in a recent work that if entangled measurements are allowed, you can do this with a mere $$O(d/\varepsilon^2)$$ copies of $$\rho$$. But using entangled states comes with its own share of problems. On the other hand if you disallow entanglement, as Bubeck et al show, you need $$\Omega(d^{3/2}/\varepsilon^2)$$ measurements. This paper asks: for which states $$\sigma$$ can you improve upon this bound. The work takes inspirations from a la “instance optimal” bounds for identity testing. Authors show a fairly general result which (yet again) confirms that the quantum world is indeed weird. In particular, the main result of the paper implies that the copy complexity of (the quantum analog of) identity testing in the quantum world (with non-adaptive queries) grows as $$\Theta(d^{1/2}/\varepsilon^2)$$. That is, the number of quantum measurements you need increases with $$d$$ (which is the stark opposite of the behavior you get in the classical world).