How do animals adapt to a partially or fully deaf individual of their group?

In eusocial animals for which hearing is important to communicate between individuals, is there any species apart humans for which there are some evidence that the group adapts their acoustic communication to a fully or partially deaf individual of the group?

For instance, by systematically vocalizing louder/closer to a partially deaf individual, or switching the communication modality (e.g. acoustics to touching) for a fully deaf individual, or by showing more support to them when an alarm call is raised, etc.

I have not found any information after a quick search on the web and Google Scholar.

Did you search for possible literature? If so it would be good to give some indication of that. Also, I think "eurosocial" should be "eusocial", right?


Minimum cost of solving the Eni-Puzzle

You're tasked with writing an algorithm to efficiently estimate cost of solving an [Eni-Puzzle](http://www.enipuzzles.com/buy/eni-braille-puzzle-with-bold-colors) from a scrambled state as follows:

You're given m lists of containing n elements each(representing the rows of the puzzle). The elements are numbers between 0 and n-1 inclusive (representing the colors of tiles). There are exactly m occurrences of each integers across all m lists (one for each list).

For example:

    m=3, n=4 :

    [[3, 0, 3, 1],            [[1, 3, 0, 1],
     [1, 0, 2, 2],     or      [0, 2, 3, 1],
     [3, 0, 1, 2]]             [0, 3, 2, 2]]

You can manipulate these lists in two ways:

1: Swapping two elements between circularly adjacent indices in (non circularly) adjacent lists. Cost=1.

Ex:

    m=3, n=4 :

    Legal:
    Swap((0,0)(1,1))
    Swap((1,0)(2,3)) (circularly adjacent)

    Illegal:
    Swap((0,0)(0,1)) (same list)
    Swap((0,0)(2,1)) (lists are not adjacent)
    Swap((0,0)(1,0)) (indices are not circularly adjacent (they're the same)
    Swap((0,0)(1,2)) (indices are not circularly adjacent)

  2. Circularly shifting one of the lists (Cost=number of shifts)

Your algorithm must efficiently calculate minimum cost required to manipulate the lists such that the resulting lists are all rotations of each other (meaning the puzzle can be fully solved from this state using only rotation moves) i.e.:

    [[0, 1, 2, 3]          [[2, 1, 0, 3]
     [3, 0, 1, 2]    and   [0, 3, 2, 1]
     [1, 2, 3, 0]]         [3, 2, 1, 0]]

...are both valid final states.

Instead of lists, you may use any data structure(s) of your choice to represent the puzzle, so long as the cost of simulating a valid move (sliding or rotating) on the puzzle with this representation is O(n*m). The setup cost of initializing this data structure can be disregarded.

A winning solution will compute the cost in the lowest asymptotic runtime in terms of m and n. Execution time will be assessed as a tie breaker.

@Jonah Because The costs I've outlined here are not the actual number of moves required to make equivalent moves on the puzzle. "Swapping" moves have a higher cost. To solve the actual puzzle, you first reach the state I described, or a state that is only one sliding move away. Because my specifications don't allow direct sliding moves (swapping equal indices) like the puzzle does for the blank space, I don't need to consider this latter case. This reduces the problem so that only the two move types I described need to be considered and the concept of a moving  "blank space" can be ignored.

@JonathanAllan Yes. I've edited this to be more clear.

why not define the winning state as the actual state where they're all lined up?

Hi and welcome to PPCG :) I think you do not need fastest-code or code-challenge since you only actually specify the winning criterion as the algorithmic speed. Further, I think you should specify if you mean the asymptotic worst case, or average case (best case is not a good idea, for reasons that are hopefully obvious). For future use, we have a sandbox to post challenges to work out issues before you post to the main site. Good luck!


Share Conversion between Different Finite Fields

Let us have any linear secret sharing scheme (LSSS) that works on some field $Z_{p}$, where p is some prime or a power of a prime e.g., Shamir Secret Sharing, Additive secret Sharing. The problem at hand is simple, for any secret shared value in $Z_{p}$, is it possible to convert it (and its shares) to elements on $Z_{q}$, where q could be either greater or smaller than p? Note that **I do not need** conversion from $Z_{2^n}$ to $Z_{2}$.

I am aware of the results on [PRSS](http://link.springer.com/chapter/10.1007%2F978-3-540-30576-7_19), and well as in this [2008](https://eprint.iacr.org/2008/221.pdf) work, however the former does not address field conversion, and the latter, have explanations that are not clear nor it offers perfect security.

Any help is more than welcome!

@Dragos... Btw.... Are you from Bristol's group? that Dragos?

I see..Even converting shares from $Z_p \rightarrow Z_2^{r}$ is a hard problem - at least I have encountered it several times and don't know how to solve it efficiently other than bit decompose and simulate the binary circuit in $Z_p$.

@Dragos. My inputs are bounded by the conversion target, if I do any transformation to a smaller field, let say $Z_{2}$ I would loose information (or be forced to use bit decomposition which I also want to avoid). This is why I cannot use $Z_{2}$, as I pointed out. Any idea is welcome!

For me, arithmetic means $Z_p$. You can use the method above by first converting from $Z_p \rightarrow Z_2$ and then from $Z_2 \rightarrow Z_q$.

@Dragos, as I pointed out on the explanation of the problem I 'm not interested on $Z_{2}$ to $Z_{2^r}$ conversions. Thanks anyways!

There is a way to do share conversion from binary to arithmetic and vice-versa using this paper: thomaschneider.de/papers/DSZ15.pdf


RSA key such that pi deciphers to your name per RSA-OAEP

Can you efficiently construct an RSA public/private key pair with $8k$-bit public modulus such that $C=\left\lfloor\pi\,2^{8k-2}\right\rfloor$ deciphers per RSA-OAEP to your name as a bytestring in ASCII or UTF-8?

The decryption must be per RSAES-OAEP of [PKCS#1v2.2](http://mpqs.free.fr/h11300-pkcs-1v2-2-rsa-cryptography-standard-wp_EMC_Corporation_Public-Key_Cryptography_Standards_\(PKCS\).pdf#page=21), SHA-256 hash, no label, MGF1 with SHA-256, and sucessful. The key pair must conform¹ to [section 3](http://mpqs.free.fr/h11300-pkcs-1v2-2-rsa-cryptography-standard-wp_EMC_Corporation_Public-Key_Cryptography_Standards_\(PKCS\).pdf#page=6). It could come as $n$, $e$, $d$, or as a PEM text encoding of the private key per the format of [section A.1.2](http://mpqs.free.fr/h11300-pkcs-1v2-2-rsa-cryptography-standard-wp_EMC_Corporation_Public-Key_Cryptography_Standards_\(PKCS\).pdf#page=41) acceptable by an [ASN.1 decoder](https://lapo.it/asn1js/). Kudos if it passes² OpenSSL's [`RSA_check_key`](https://gitlab.com/gitlab-org/build/omnibus-mirror/openssl/blob/706457b7bda7fdbab426b8dce83b318908339da4/crypto/rsa/rsa_chk.c), more kudos if $8k\ge1024$, the higher the better.

$C$ is the first $k$ bytes of [these](http://mpqs.free.fr/C.txt) (in hex) for $8k$ up to $2^{16}$ bits.

* * *

Update: [this](https://crypto.stackexchange.com/a/80322/555) answers in the affirmative, for whatever usual $k$, with $p$ and $q$ equal-size primes, and $N$ hard to factor. The next frontier is a low $e$, say in $[3,2^{256})$, ideally $65537$.

Further stunts are possible, like having $C$ or $2$ the signature of anything per any usual RSA signature scheme, even deterministic and/or with message recovery.

As a consequence: verifying a signature of a file against Alice's RSA public key (including, certified and used for other purposes) is proof neither that the file is unchanged since signature, nor that Alice was the signer.

Example where that matters: the signature of a file is on a trusted site, the file is not. Alice manages to get her public key (which she uses normally) in the verifier's keystore (with the key identifier of the legitimate signer, if there is such thing in the signature). The verifier, who just uses crypto as a magic tool, sees that the signature verifies, and (rightly) trusts the secure site to hold only trusted signatures of trusted files. There is a chance that a file alteration by Alice goes uncaught, or/and that she can wrongly convince the verifier that she made the signature at the date notarized by the trusted site.

Update 2: Some consequences of the same possibility are discussed in Dennis Jackson, Cas Cremers, Katriel Cohn-Gordon and Ralf Sasse's [_Seems Legit: Automated Analysis of Subtle Attacks on Protocols that Use Signatures_](https://eprint.iacr.org/2019/779), originally in [proceedings of CCS 2019](https://doi.org/10.1145/3319535.3339813).

* * *

¹ That is: public modulus $n$ must be the product of $u\ge2$ distinct odd primes, odd public exponent $e$ with $3\le e<n$, private exponent $d$ with $0<d<n$ and $e\,d\equiv1\pmod{r-1}$ for each prime $r$ divisor of $n$.

² For keys otherwise per the above, it limits $u$ (including $u=2$ for $n$ less than 1024-bit, $u\le3$ for $n$ less than 4096-bit, see [`rsa_multip_cap`](https://gitlab.com/gitlab-org/build/omnibus-mirror/openssl/-/blob/706457b7bda7fdbab426b8dce83b318908339da4/crypto/rsa/rsa_mp.c#L100)). It also requires the full factorization of $n$ to be given, as well as reduced exponents and multiplicative inverses.


Finding $x$ such that $g^x\bmod p<p/k$?

In a Schnorr group as used for DSA, of prime modulus $p$, prime order $q$, generator $g$ (with $p/g$ small), how can we efficiently exhibit an $x$ with $0<x<q$ such that $g^x\bmod p<p/k$, for sizable $k$ but $k\ll\sqrt q$ ?

I see that for small $k$, it is enough to try incremental values of $x$ until finding an $x$ that fits, with expected cost $O(k)$ modular multiplications in $\mathbb Z_p^*$. Is there better?

Assume $p$ is an $l$-bit prime; $q$ is an $n$-bit prime with $q$ dividing $p-1$; and $g=h^{(p-1)/q}$ for some (random?) $h$ in $\mathbb Z_p^*$. For concrete values, assume $l\approx1024$, $n\approx160$, $k\approx2^{64}$.

Update: I'm expecting the problem to be hard, and thus that the more difficult problem of exhibiting $x$ with $g^x\bmod p$ in a range of width $p/k$ must be hard.

Can you please provide me with some real values of variables in question instead of me attempting with random values.

@pintor: no, I have made no progress nor got more feedback than the above comments.

@fgrieu, did you get any more updates on the problem? I'm also curious

This seems to reduce to a discrete logarithm problem in the multi-target setting, with a potentially very high target number depending on $k$. For a $k\approx \sqrt{p}$ index calculus seems like the best choice. Once you have one solution, getting more is relatively fast. Unsure if there's something better.

@SamuelNeves: yes; the only constraint on $g^x\bmod p$ is that it is small (about $\log_2(k)$-bit smaller than $p$ is).

Do you get to choose what the $g^x \mod p$ value is?

@puzzlepalace: thank you for finding a hole; plugged it.

Choose $x = 0$ ? Runs in $\Theta(1)$  ;)


Time-memory tradeoffs in Shor's algorithm

Can a quantum computer with insufficient qubits to factor an integer of a given size make _any_ progress in factoring it? For example, what if a quantum computer is only one qubit short of what is necessary to attack a specific integer? Is it capable of making any progress in factoring it, or would it be just as useless as a 2 qubit machine? Assume qubits refer to logical qubits in a general-purpose cryptanalytic quantum computer with sufficient quantum error correction to solve the problem of decoherence.

Given that qubits can be thought of as the memory for quantum computers, I am essentially asking if time-memory tradeoffs are possible with Shor's algorithm when too few qubits are available.

Interesting question. One problem certainly could occur when you have less qubits than the number of the period $r$ ($a^r \bmod N$). This would probably mess up the inverse quantum fourier transform which amplifies the correct period (quantum wave interference), thus rendering the whole computation impractical. In that case you can't find $r$.

Quantum computers, like classical ones, needs a minimum amount of memory to calculate any given pair of algorithm and input. This is why Turing completeness assumes infinite memory. Even quantum computers can only evaluate the the possibilities that fits in the qubit memory it has. Every algorithm and input has different limits, but it always exists. Exceeding the minimum necessary memory allows you to add further optimizations to attempt to improve performance. However, sometimes you can break the algorithm into smaller individual steps that each need less memory.

This answer from Quantum Computing.SE gives some interesting references in the third paragraph.


Does the bias in RC4 drop asymptotically further in the keystream?

It's well-known that the RC4 keystream has significant biases that become less prominent later in the keystream. The most severe bias is in the second byte, which has a 128-1 bias towards zero. Other biases remain, and it's typically recommended to drop between 768 and 3072 bytes of the keystream.

Will dropping one more byte _always_ reduce the bias, or is there a point when the bias is as low as it is going to get and it won't get lower as the keystream goes on? It doesn't matter if the bias is negligible.

Note that I am only talking about short-term biases, not long-term ones which RC4-dropN can't solve.

**Does an _N_ exist that results in minimum bias in RC4-dropN?**

@MaartenBodewes I have not yet, but I also haven't done much research into it. There's a lot of academic text on the (in)security of RC4 which I should familiarize myself with.

Hey Forest. This question popped up again. Unfortunately I don't know the answer, but maybe you've found one in the mean time?

@kodlu The paper I referenced in my first comment is rc4nomore.com/vanhoef-usenix2015.pdf.

please point to the right paper, there are a few with these authors. also, proving convergence rates in random processes is notoriously hard, in general.

@IlmariKaronen I am asking whether a minimum level of bias can be reached in a finite number of steps.

If I understand your last paragraph right, you seem to actually be asking whether the asymptotic long-term level of bias is actually attained within a finite number of steps, or whether the asymptote is only approached but never reached. Is that correct?

I'm reading the Vanhoef and Piessens paper from 2015 to see if I can find the answer myself. If this is a particularly stupid question (it probably is) and the answer turns out to be obvious, I'll delete or self-answer it.


Partial circulant matrices: Is there a non-zero vector $v\in \{-1,0,1\}^n$ such that $Mv=0$?

The following question arose as a side product of some work I have been part of recently. An $m$ by $n$ $(0,1)$-matrix $M$ is partial circulant if it can be formed by taking the first $m$ rows of a [circulant matrix](http://en.wikipedia.org/wiki/Circulant_matrix) and all its entries are either $0$ or $1$. We assume that $m\leq n$.

Given such a partial circulant matrix $M$, what is the computational complexity of the following question?

> Is there a non-zero vector $v\in \\{-1,0,1\\}^n$ such that $Mv=0$?

The problem is clearly in NP but my guess is that it is not NP-hard (unlike [this related question](https://cstheory.stackexchange.com/questions/20277/decide-whether-a-matrixs-kernel-contains-any-non-zero-vector-all-of-whose-entri)). I have not, however, found a poly time solution.

The circulant case was in fact considered at mathoverflow.net/questions/168474/… . However, it seems that there is fatal bug in one of the answers and the other answer is not a complete solution.

would it be more natural to study the circulant case 1st vs the partial circulant? also (idea) the other problem answers are formulated in terms of subset sum problem, how would this problem be formulated that way (ie as a constrained or special case of subset sum problem)? note there are many subset sum variants studied in the literature that might be close...


Are monotone Boolean functions in P well-approximated by monotone polynomial-size circuits?

**Question 1:** Is it true that for every polynomial $p(n)$ and $\epsilon >0$ there is a polynomial $q(n)$ such that every monotone Boolean function on $n$ variables that can be expressed by a Boolean circuit of size $p(n)$ can be $\epsilon$-approximated by a _monotone_ Boolean circuit of size at most $q(n)$.

A function $f$ is $\epsilon$-approximated by a function $g$ if they agree on at least $(1-\epsilon)$ fraction of inputs.

We can ask a slightly more general question. Let $\mu_p$ denote the Bernoulli measure on $\\{0,1\\}^n$ where every variable is '1' with probability $p$. For a (non-constant) monotone function $f$ let $p_c(f)$ be the value such that $\mu_{p_c}(\\{x: f(x)=1\\})=1/2$.

**Question 2:** Is it true that for every polynomial $p(n)$ and $\epsilon >0$ there is a polynomial $q(n)$ such that every monotone Boolean function $f$ on $n$ variables, there is a Boolean function $g$ that can be expressed by a monotone Boolean circuit of size $q(n)$ such that for $p=p_c(f)$, $\mu_p(\\{x: f(x) \ne g(x) \\}) \le \epsilon$.

Of course, the instinctive thought is that the answers for both these question is **NO**. Is it known? Razborov famously proved that matching cannot be expressed by a monotone Boolean circuit of polynomial size. But matching can be approximated in its critical probability by the property that there are no isolated vertices and this property admits a monotone (low depth) circuit.

I asked the analog questions (Problems 1,2,3) for $AC^0$ and $TC^0$ in [this blog post](https://gilkalai.wordpress.com/2010/02/10/noise-stability-and-threshold-circuits/).

Dear Gil, now I see the point: I just wrongly interpreted your question! We indeed have that every monotone circuit, which needs only to coincide with b-Clique on an extremely small, but special set of inputs, must be large. You, however, do not specify this subset of "hard" inputs, only its ratio $1-\epsilon$. This is a very interesting question. B.t.w. that result (on clique approximation) is Thm. 9.26 in my book.

"Every monotone circuit separating graphs consisting of complete a-partite graphs with a > 32 from graphs consisting of b-cliques for a < b < n/32 must have size exponential in min{a,n/b}^{1/4}."This is interesting (reference?) but I am not sure it is relevent - namely I don't see that my notion of $\epsilon$-approximation is relevant to the result you mention.

Dear Gil, I interpreted your Question 1 as "if a monotone boolean function $f$ cannot be $\epsilon$-approximated by a small monotone circuit, then $f$ has no small non-monotone circuits" (with "small" meaning "of polynomial size"). If the interpretation is correct, the function I mentioned only weakly approximates b-Clique function, and still requires large monotone circuits.

Dear Stasy, I don't see how the results you mention refer to Questions 1 and 2. (As I said, I also expect a 'no' answer..)

Gill, what about the fact that every monotone circuit separating graphs consisting of complete a-partite graphs with a > 32 from graphs consisting of b-cliques for a < b < n/32  must have size exponential in min{a,n/b}^{1/4}. The approximation density seems to be here enough (is it?) to say that your conjecture would definitely imply P!=NP.

Thanks Gil, this seems like a good reason to update my prior to "NO".

Dear Andras, Alas, counting arguments are too weak for things of this kind. A YES answer will tell you that an argument that (1) some monotone NP-complete problem cannot be approximated by a polynomial size monotone circuit in the critical probability, automatically implies that (2) it cannot be approximated by a polynomial size  circuit in the critical probability. (2) is a stronger statement than $NP \ne P$ but I dont regard (1) as hopeless. (You may think that the answer is YES but proving it is hopeless, but I find it easier to think that the answer is NO and its not beyond reach.)

Why is NO the instinctive response?  Monotone functions have all sorts of nice properties, so a priori this doesn't seem all that unlikely to me.  Are you perhaps thinking of a counting argument?


Weighted Hamming distance

Basically my question is, what kind of geometry do we get if we use a "weighted" Hamming distance. This is not necessarily Theoretical Computer Science but I think similar things come up sometimes, for instance in randomness extraction.

Define:

$d(x,y)=$ the Hamming distance between binary strings $x$ and $y$ of length $n$, $=$ the cardinality of $\\{k: x(k)\ne y(k)\\}$.

For a set of strings $A$,

$d(x,A)=\min \\{ d(x,y): y\in A\\}$.

The _$r$ -fold boundary of_ $A\subseteq \\{0,1\\}^n$ is

$$\\{x\in\\{0,1\\}^n: 0 < d(x,A)\le r\\}.$$

Balls centered at $0$ are given by

$$ B(p)=\\{x: d(x,0)\le p\\}, $$ where $0$ is the string of $n$ many zeroes.

A _Hamming-sphere_ is a set $H$ with $B(p)\subseteq H\subseteq B(p+1)$. (So it's more like a ball than a sphere, but this is the standard terminology...)

Now, Harper in 1966 showed that for each $k$, $n$, $r$, one can find a Hamming-sphere that has minimal $r$-fold boundary among sets of cardinality $k$ in $\\\\{0,1\\\\}^n$. So a ball is a set having minimal boundary -- just like in Euclidean space.

The cardinality of $B(p)$ is ${n\choose 0}+\cdots {n\choose p}$.

The $r$-fold boundary of $B(p)$ is just the set $B(p+r)\setminus B(p)$, which then has cardinality ${n\choose p+1}+\cdots+{n\choose p+r}$.

So far, so good. But now suppose we replace $d$ by a different metric $D$: first let $d_j(x,y)$ be the Hamming distance between the prefixes of $x$ and $y$ of length $j$, and then $$ D(x,y)=\max_{j\le n}\ \frac{d_j(x,y)}{f(j) }$$ where $0\le f(j)\le j$. (For example we could have $f(j)=\sqrt{j}$, or $f(j)=j/\log j$.)

This is supposed to make $D(x,y)$ small if the differences of $x$ and $y$ do not clump together at small values of $j$.

# Questions

> Is the minimum $r$-fold boundary (under $D$) realized by a $D$-ball?
>
> Is there a better definition of $D$?
>
> Under the metric $D$, what's the minimum size of the $r$-fold boundary of a subset of $\\\\{0,1\\\\}^n$ having cardinality $k$? (A reasonable lower bound would be nice.)

(Cross-[posted](https://mathoverflow.net/questions/38221/geometry-in-a-hamming-box) on MathOverflow).


To what extent MSO = WS1S, when adding relations?

[This question has been asked on MathOverflow with no luck a month ago.]

Let me first clarify my definitions. For a word $w \in \Sigma^*$, with $\Sigma =\\{a_1, \ldots, a_n\\}$, I define two structures:

$\mathbb{N}(w) = \langle \mathbb{N}, <, Q_{a_1}, \ldots, Q_{a_n} \rangle$,

and the more usual _word model_ :

$\mathbb{N}^r(w) = \langle \\{0, \ldots, |w|-1\\}, <, Q_{a_1}, \ldots, Q_{a_n} \rangle$,

where $Q_{a_i} = \\{p \mid w_p = a_i\\}$.

Then WS1S is the set of second order formulas with models of the form $\mathbb{N}(w)$, with order, and for which second order quantification is limited to finite subsets of the domain. MSO is the set of monadic second order formulas with models of the form $\mathbb{N}^r(w)$, with order.

The usual proof that REG = WS1S proves at the same time that MSO = WS1S. My question is then, for which first or second order relations can we keep this to be true?

For instance, if we add a unary predicate $E(X)$ which says that a (monadic) second order variable contains an even number of objects, we add no power, as $E(X)$ is expressible as "there exists $X_1$ and $X_2$ that partition $X$, in such a way that if an element is in $X_i$ the next one in $X$ is in $X_j$, $i \neq j$, and the first element of $X$ is in $X_1$ and the last is in $X_2$."

Now, if we add a predicate $|X| < |Y|$, then WS1S becomes undecidable (see Klaedtke & Ruess, 10.1.1.7.3029), while MSO stays trivially decidable.

Thank you.

* * *

**Edit:** As a side question, ... is this question of interest? I mean, I'm no expert in the field, so I'm not sure this question is relevant.

Your model $\mathbb{N}(w)$ is very unusual : what is the need of considering a finite word on an infinite underlying structure ? If you forget the letter predicates (which do not change the problem a lot), you are in fact comparing MSO on finite linear orders, and WS1S on the order $\omega$. This is strange, because it is more intuitive to compare different logic formalisms on the same structure.

What are your reasons to think this question is uninteresting?  From a practical point of view, it is useful to know when you can restrict yourself to finite models, isn't it? For the record, I received no comment on MO.

Was there no joy on MO because they couldn't figure it out, or because they found your question uninteresting? (I'm guessing the latter)

also see the greasemonkey hack mentioned here: meta.cstheory.stackexchange.com/questions/3/latex-math-support


Descriptive complexity of communication complexity classes

It is well known that some major complexity classes, like P or NP, admit a full logical characterization (e.g NP = existential 2nd order logic by Fagin's theorem). On the other hand, one can also define complexity classes in communication complexity (where P = problems solvable with poly(logN) communication etc. - see [Complexity classes in communication complexity theory](http://dl.acm.org/citation.cfm?id=1382962) for more).

My question is - are any descriptive complexity characterizations known for communication complexity classes (or do any such results from standard complexity classes transfer to communication setting easily)?

You may want to limit the computational power of the parties, which is not done in the usual communication complexity models.


Does $EXP\neq ZPP$ imply sub-exponential simulation of BPP or NP?

By simulation I mean in the Impaglazzio-Widgerson [IW98] sense, i.e. sub-exponential deterministic simulation which appears correct i.o to every efficient adversary.

I think this is a proof: if $EXP\neq BPP$ then from [IW98] we get that BPP has such a simulation. Otherwise we have that $EXP=BPP$, which implies $RP=NP$ (because $NP \subseteq BPP$) and $EXP \in PH$. Now if $NP=RP=ZPP$ we have that $PH$ collapses to $ZPP$ and as a result $EXP$, but this cannot happen because of the assumption, so $RP\neq ZPP$ and this by the Kabanets paper "Easiness assumptions and hardness tests: trading time for zero error" implies that RP has such a simulation and as a result also NP.

This sounds like it could be a useful gap theorem. Does anyone know if it appears anywhere?

ZPP is closed under complement, and contained in NP. So, $\mathrm{NP\subseteq ZPP}$ implies NP = ZPP = coNP, hence PH = NP = ZPP.

(Just for reference): Identical question on MO: mathoverflow.net/questions/35945. Maybe someone finds the comments there inspiring.

Very interesting.  I haven't seen this argument before, but I'm not by any means an expert in these things...


Interesting PCP characterization of classes smaller than P?

The PCP theorem, $\mathsf{NP} = \mathsf{PCP}(\mathsf{log}\, n, 1)$, involves probabilistically checkable proofs with polynomial time verifiers, so the smallest class that can be characterized in this way (that is, $\mathsf{PCP}(0, 0)$) must be $\mathsf{P}$. There are also PCP characterizations of larger complexity classes (for example, $\mathsf{NEXP} = \mathsf{PCP}(\mathsf{poly}, \mathsf{poly})$), also using polynomial time verifiers.

Can we achieve an interesting (that is, not immediately following from the definitions) PCP characterization of smaller complexity classes by restricting the time or space used by the verifier? For example, by using a logarithmic space verifier, or an $\mathsf{NC}$ circuit verifier?

Your comment is contradictory to your question where you count “PCP(0, 0) = P” as a PCP characterization of P.

I suppose I meant are there any characterizations that don't follow immediately from the definition, in the same way that PCP(log n, 1) is non-obvious characterization of NP.

Why not? If you restrict the space of the verifier to log, then PCP(0, 0) obviously becomes equal to L. And this is a PCP characterization of L if you count PCP(0, 0)=P as a PCP characterization of P. I cannot see the point of the question.


Is Hankelability NP-hard?

I asked this question on [SO](https://stackoverflow.com/questions/29484864/an-algorithm-to-detect-permutations-of-hankel-matrices) on April 7 and added a bounty which has now expired but no poly time solution has been found yet.

I am trying to write code to detect if a matrix is a permutation of a Hankel matrix. Here is the spec.

**Input:** An n by n matrix M whose entries are 1 or 0.

**Output:** A permutation of the rows and columns of M so that M is a [Hankel matrix](http://en.m.wikipedia.org/wiki/Hankel_matrix) if that is possible. A Hankel matrix has constant skew-diagonals (positive sloping diagonals).

When I say a permutation, I mean we can apply one permutation to the order of the rows and a possibly different one to the columns.

A very nice $O(n^2)$ time algorithm [is known](https://stackoverflow.com/questions/20704900/determine-if-some-row-permutation-of-a-matrix-is-toeplitz) for this problem if we only allow permutation of the order of rows.

Peter de Rivaz pointed out this [paper](http://www.mat.ucsb.edu/~g.legrady/academic/courses/15w259/d/re_orderableMatrix.pdf) as a possible route to proving NP-hardness but I haven't managed to get that to work.

Cross-posted now to mathoverflow.net/questions/204294/is-hankelability-np-hard

@IgorShinkar I mean first some permutation on the order of the rows and then a possibly different permutation on the order of the columns, then stop.

Do you mean apply first some permutation on the rows and then some permutation on the columns? or do you allow more permutations?

@Kaveh Thanks for the question. The permutation applied to the order of the columns can be different from the one applied to the order of the rows.

Do you mean that the same permutation is applied to rows and columns? (my got feeling says this is in P, if a matrix is Hankelable with different diagonal values there aren't that many possibilities for the permutation.)

Just a guess: maybe this problem is GI-complete?


Model-checking for three-variable logics and restricted structures

Denote the $k$-variable fragment of logic $L$ by $L^{(k)}$. The model-checking problem for a logic $L$ with respect to a class of structures $C$, denoted $MC(L,C)$, is the decision problem

> $MC(L,C)$
>  _Input:_ formula $\phi$ of $L$, structure $S$ from $C$
>  _Question:_ does $S$ satisfy $\phi$?

Is there a logic $L$, with associated class of structures $C$, and a subclass $D$ of $C$, such that
1\. $MC(L^{(3)},D)$ is "easy",
2\. $MC(L,D)$ is "hard", and
3\. $MC(L^{(3)},C)$ is "hard"?

With "easy" vs. "hard" I mean decidable vs. undecidable, PTIME vs. NP-hard, LogCFL vs. P-complete, or similar dichotomies.

# Motivation

For many logics the three-variable fragment is enough to express "hard" properties (this is true for MSO and FO over ordered structures). So results about undecidability often carry across from the logic to its three-variable fragment. There is also often a way to reduce the arity of predicates used in formulas efficiently (for instance, SAT can be reduced to 3SAT with a linear increase in formula size). Reducing arity facilitates expressing some formulas with fewer variables.

On the other hand, there exist logics which are "easy" for some classes of structures yet "hard" in general. For instance, the model-checking problem for MSO is "easy" (linear time) on unordered graphs satisfying the property "has treewidth less than $k$" for any fixed $k$, but "hard" (NP-complete) on unordered graphs in general.

I am asking whether there are any known examples where the restriction to 3 variables interacts with the property defining the subclass $D$ in an essential way to yield tractability, yet where neither of these restrictions on their own is enough.

Apologies for the vagueness of the question: I am trying to leave this general because I can't think of any examples. As soon as I restrict $D$ enough to ensure condition 1 holds, condition 2 seems to break. I suspect there are some unnatural classes which would work, but ideally $D$ should be "nice", at least hereditary and closed under isomorphism. As a further non-example, model-checking for FO is PSPACE-complete while model-checking for $FO^{(3)}$ is PTIME-complete; here the restriction to a finite number of variables is already enough to ensure an "easy" model-checking problem and condition 3 fails.

Definitions for completeness: FO is [first-order logic](http://en.wikipedia.org/wiki/First-order_logic), MSO is monadic [second-order logic](http://en.wikipedia.org/wiki/Second-order_logic), where quantification over sets of individuals is allowed, as well as quantification over individuals.

Have you made any progress on that question, András?


In an $m$ by $n$ Boolean matrix, can you find a square block whose four corners are ones in $O(m \cdot n)$ time?

**Decision Problem**

Input: An $m$ by $n$ Boolean matrix $M$.

Decision Question: Does there exist a square block within $M$ such that upper-left corner entry == upper-right corner entry == lower-left corner entry == lower-right corner entry == 1? That is, all four corners of the square block are 1's.

**Cubic Time Solution**

We know that this problem can be solved in $O(m \cdot n \cdot min\\{m,n\\})$ time. The approach involves scanning through the matrix row by row. For each row, for each pair of 1's in that row, we check whether those 1's form an edge of a square block whose four corners are 1's.

**Our Question**

What is the time complexity of this problem? Is there a quadratic time solution? In particular, can we solve this decision problem in $O(m \cdot n)$ time?

**Extra Background**

  1. If you're just looking for a rectangular block whose four corners are ones, this can be solved in $O(m \cdot n)$ time. Many variations to this problem can be solved in $O(m \cdot n)$ time as well. I co-authored a paper on this subject.

  2. The paper ["Finding squares and rectangles in sets of points"](https://doi.org/10.1007/BF01931281) investigates a related problem from computational geometry where you're given a set of points in a 2D plane and you want to know if there are four points that form an axis-parallel square.

Written together with Eevvoor.

It feels somehow like an FFT would help, although I haven't been able to puzzle out details. You're looking for something translation-invariant, and working in frequency space often helps with that sort of thing. Tossing out this comment in case someone else can spot something.

@MichaelWehar: ok, let me know if you make some progress!

@MarzioDeBiasi It turns out that my reduction doesn't quite work.  I'm seeing if I can fix it.

@MarzioDeBiasi I guess that the right isosceles triangle problem is reducible to triangle finding.  We can convert the matrix to a graph where vertices are rows, columns, and diagonals.  Also, entries with 1's are associated with edges.  But, can we do any better than matrix multiplication time?

@MarzioDeBiasi Please feel welcome to share these works!  I think they could be pretty helpful.  :)

@michaelwehar my idea of right triangle is a square with three 1s on the corners (no matter where the missing one is) but there is a reduction from mine to yours, where the missing one is in the bottom right (just rotate 90 and replicate four times). BTW there are some works both on monochromatic square and triangle free grids (somewhat related if you interpret "colors" with small monochromatic (sub)boxes with 1s on the diagonal)

@MarzioDeBiasi I thought about your right isosceles triangle problem. Just to confirm, this problem is asking for a square block where upper-left corner entry == upper-right corner entry == lower-left corner entry == 1, but we don't care whether lower-right corner entry is 0 or 1? I think that I have some potentially promising ideas for this problem. I'm going to try to formalize the ideas and I hope to share in a few days. Thanks again!

Even if you restrict the search to right isosceles triangles, it seems impossible to have an $O(mn)$ algorithm

@DavidEppstein I wasn't quite sure how many 1's there could be without forcing there to be a square block so this is very helpful!  User whosyourjay showed a construction related to affine planes on how many 1's there could be without forcing there to be a rectangular block whose corners are 1's. If I recall correctly, the near-tight bound was something like $m \cdot n^{1/2}$ (it had degree 3/2).

This is more dead end than answer, but: there exist sets of $mn^{1-o(1)}$ nonzeros with no square, formed by filling diagonals according to a near-linear-size progression-free set (en.wikipedia.org/wiki/Salem%E2%80%93Spencer_set). So an algorithm that answers yes if dense enough to force a square and switches to the naive O(nonzeros times min(m,n)) otherwise can't be strongly subcubic.

@JoshuaGrochow Yes, when searching for a rectangular block, the problem is related to finding a four cycle in a graph which is solvable in quadratic time.  However, when searching for a square block, I don't know what can be done.  Maybe there is a way to reduce triangle finding to this problem.

Seems a little similar to finding a triangle in a graph. If you get a subcubic reduction from that problem that'd be the end of the story for now.

@daniello Yes!  That's a good point.  When the input matrix is rectangular, we can reduce it to the case where the input matrix is square.  Thank you.  :)

You can assume wlog that $m \leq n$ (otherwise transpose) and that $n \leq 2m$ since otherwise you can cover the matrix by $2n/m$ matrices of size $m \times 2m$ that cover all square blocks. So wlog the input matrix is square $n$ by $n$.


Problem unsolvable in $2^{o(n)}$ on inputs with $n$ bits, assuming ETH?

If we assume the Exponential-Time Hypothesis, then there is no $2^{o(n)}$ algorithm for $n$-variable 3-SAT, and many other natural problems, such as 3-COLORING on graphs with $n$ vertices. Notice though that, in general, encoding the input for $n$-variable 3-SAT or $n$-vertex 3-COLORING takes something like $O(n\log n)$ bits. For example, to describe a sparse graph as input to 3-COLORING, for each edge we would have to list its endpoints. So the lower bound is not exponential in the length of the input. Therefore, my question is the following:

Is there a problem for which no $2^{o(n)}$ algorithm exists for inputs of length $n$ bits (assuming ETH)?

Ideally, the problem would be in NP (no cheating with succinct NEXP-hard problems!) and be reasonably natural, but I won't be picky.

Let me also note that after digging around I found that there are efficient ways to encode planar graphs with $O(n)$ bits. So, if one could find a problem that takes time exponential in the number of vertices even for planar graphs, the question would be settled. However, because planar graphs have treewidth $O(\sqrt{n})$, most natural problems have sub-exponential algorithms in this case.

I believe that it is an open question if we can have a lower bound $2^{\Omega(n)}$ under ETH, where $n$ is the bit size. We know that proving lower bound $\Omega(c^n)$ under SETH would disprove SETH.

How about the following problem, for some large constant $c>0$?  Given the encoding of a non-deterministic TM $M$ and binary string $w$, does $M(w)$ have an accepting computation of length at most $|w|^c$?  This should work if anything does... (?)

@AviTal This paper comes to mind arxiv.org/abs/cs/0102005 . The usual keywords for this line of research seem to be "compact" and "succinct" encodings or representations. (succinct is stronger in that it is optimal up to an additive term instead of a multiplicative factor for compact).

Would disordered lattice tiling work? Without disorder the problem is NEXP-complete [arXiv:0905.2419] but with disorder (e.g., a vertex-dependent constraint on the tiles) the input would need to be $O(n)$. This is reasonably natural: it would arise in physics as the zero-temperature partition function of a disordered vertex model.

Can you point to a reference where I can find efficient ways to encode planar graphs with O(n) bits? (I assume that n is the number of vertices). If so, there are NP-Complete problems for planar graphs and maybe the problem can also be presented in O(n) bits using these methods. Thanks.

It is probably not possible to compress $n$ variable SAT instances to $O(n \log n)$ as stated in the question (Dell, van Malkebeek, "Satisfibility Allows No Nontrivial Sparsification Unless The Polynomial-Time Hierarchy Collapses"). However, 3-SAT has no $2^{o(m)}$ algorithm where $m$ is the number of clauses, as shown by Impagliazzo and Paturi (assuming ETH). Since the hard cases have $O(m)$ variables we have $b=O(m \log m)$, so $m=\Omega(b/\log b)$, so 3-SAT has no $2^{o(b/\log b)}$ algorithm where $b$ is the input size.

A problem in NP for which our present algorithmic knowledge is consistent with such a ETH result is edge chromatic number in a dense graph. AFAIK, we do not yet know of any $2^{o(|E|)}$ time algorithms...

If you are fine with dropping the condition that the problem is in NP, then you can use any undecidable problem and you do not even need the exponential time hypothesis.  So probably you should be picky.


Sylver Coinage Game

A game in which the players alternately name positive integers that are not sums of previously named integers (with repetitions being allowed). The person who names 1 (so ending the game) is the loser.

The question is: If player 1 names ‘16’, and both players play optimally thereafter, then who wins?

It has been known that if player 1 name "5n," then player 1 wins. If player name "5n+2", the result is known(maybe palyer 2 wins, but I haven't found the source yet). 16 is the minimum number of "5n+1".

I guess that this problem is PSPACE-hard, but I haven't proved it yet.

@NealYoung The algorithm in Winning Ways only gives whether an opening move is winning or not -- in accordance with Conway's comment, it relies on a theorem saying finitely moves of the form 2^a 3^b win, and I imagine (Conway having told me of that fact before) that this is what he meant when he said that an algorithm exists. If so, he was being unclear; however, this means that Jeffe's original comment was still correct.

Here's an updated link for Jeffε's comment (as of May 2017).  Although I read Conway's comment as suggesting the problem is decidable: "Is there an algorithm for Sylver Coinage that tells you, by looking over all (possibly infinite) options, what the status of the a position is and what if any are the winning moves? The answer is yes (see Winning Ways) but I do not know what the algorithm is."

@PyRulez just writing down that regex is exponential time. However, there's an easy polynomial time test for whether you have to name 1 as your next move (and lose): it's true iff both 2 and 3 have already been named (and 1 hasn't). For if they have, then no higher numbers are available, and if they haven't, then one of those two numbers can be named next.

@SureshVenkat It is efficient. For example, if the current coins are $4$, $5$, and $7$, you effectively have a regex of (aaaa)*(aaaaa)*(aaaaaaa)*, which can be matched against efficiently.

I am considering using the construction of sum-free set, for example, the set of odd numbers is a sum-free subset of the integers, and the set $\{N/2+1, ..., N\}$ forms a large sum-free subset of the set $\{1,...,N\}$ ($N$ even). Fermat's Last Theorem is the statement that the set of all nonzero nth powers is a sum-free subset of the integers for $n > 2$.However, some basic problems of sum-free set are still unknown. How many sum-free subsets of $\{1, ..., N\}$ are there, for an integer $N$? Ben Green has shown that the answer is $O(2^{N/2})$. Can this help?

Is it even efficient (i.e P time) to check if someone has lost ? Seems like the "you lost" test is an unbounded knapsack problem.

Apparently it's open whether Sylver Coinage is decidable.  Cool.  And at least as of 2002, even Conway didn't know who wins from 16.


Complexity of the homomorphism problem parameterized by treewidth

The _homomorphism problem_ $\text{Hom}(\mathcal{G}, \mathcal{H})$ for two classes $\mathcal{G}$ and $\mathcal{H}$ of graphs is defined as follows:

> **Input:** a graph $G$ in $\mathcal{G}$, a graph $H$ in $\mathcal{H}$
>
> **Output:** decide if there is a homomorphism from $G$ to $H$, i.e., a mapping $h$ from the vertices of $G$ to those of $H$ such that, for any edge $\\{x, y\\}$ of $G$, $\\{h(x), h(y)\\}$ is an edge of $H$.

For each $k \in \mathbb{N}$, I will call $\mathcal{T}_k$ the class of the graphs of [treewidth](http://en.wikipedia.org/wiki/Treewidth) at most $k$. I'm interested in the problem $\text{Hom}(\mathcal{T}_k, \mathcal{T}_k)$, which I see as a _parameterized_ problem (by the treewidth bound $k$). My question is: **what is the complexity of this parameterized problem?** Is it known to be FPT? or is it W[1]-hard?

Here are some things that I found about the $\text{Hom}$ problem, but which do not help me answer the question. (I write $-$ for the class of all graphs.)

  * <http://www.sciencedirect.com/science/article/pii/009589569090132J>: If $\mathcal{H}$ is bipartite then $\text{Hom}(-, \mathcal{H})$ is in PTIME, otherwise it is NP-complete, but of course the NP-hardness relies on allowing arbitrary $G$.
  * [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.86.9013&rep=rep1&type=pdf](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.86.9013&rep=rep1&type=pdf): If the treewidth of $\mathcal{G}$ (modulo homomorphic equivalence) is bounded by a constant then $\text{Hom}(\mathcal{G}, -)$ is in PTIME (and otherwise it isn't, assuming FPT != W[1]). Hence, in particular my problem $\text{Hom}(\mathcal{T}_k, \mathcal{T}_k)$ is in PTIME for fixed $k$, but this doesn't tell me what is the dependency on the parameter.
  * From Flum and Grohe's book _Parameterized Complexity Theory_ , Corollary 13.17: The problem $\text{Hom}(\mathcal{T}_k, -)$ is FPT when parameterized by the _size_ of $G$ (but I am parameterizing by the treewidth)
  * <http://users.uoa.gr/~sedthilk/papers/homo.pdf>, Corollary 3.2: When fixing a specific graph $H$, the problem $\text{Hom}(\mathcal{T}_k, \\{H\\})$, parameterized by k, is FPT (this even holds for more complicated counting variants), but I do not want to restrict to fixed $H$.

This question is still open, but one remark: there is an FPT algorithm parameterized by treewidth for the graph isomorphism problem, here: epubs.siam.org/doi/abs/10.1137/…     (Daniel Lokshtanov, Marcin Pilipczuk, Michał Pilipczuk, and Saket Saurabh, "Fixed-Parameter Tractable Canonization and Isomorphism Test for Graphs of Bounded Treewidth", SICOMP.) As far as I know, unfortunately, this does not say anything about the homomorphism problem.


Is Node Multiway Cut NP-complete on planar graphs when all terminals lie on the outer face?

I am interested in the following problem.

**Node Multiway Cut on Planar Graphs with terminals on the outer face**

  * Instance: A plane graph G, and integer k, and a set $S \subseteq V(G)$ of terminals which are all incident on the outer face of G.
  * Question: Is there a set of vertices $X \subseteq V(G)$ of size at most $k$ such that all vertices of $S \setminus X$ belong to different connected components of $G - X$?

Informally, the problem asks whether all terminals can be separated with k vertex deletions, knowing that all terminals lie on the outer face. If we replace vertex deletions by edge deletions, then this is known to be possible in polynomial time by considering multiway cuts in the planar dual, and relating them to certain kind of Steiner trees ([Efficient Algorithms for k-Terminal Cuts on Planar Graphs](https://doi.org/10.1007/3-540-45678-3_29)). Since the edge-deletion version reduces to the vertex-deletion version, the edge-deletion version seems easier; no reduction in the reverse direction is known.

The question is: is Node Multiway Cut on Planar Graphs with terminals on the outer face NP-complete? The reason I am interested in this problem is that it would provide me with a starting point for another complexity lower bound if this is indeed NP-complete.

I know for sure that the algorithm I mentioned works for edge weighted Steiner tree, but one should be able to adapt it to work for vertices.

I think that this is equivalent to solving vertex weighted Steiner tree where all terminals on the outer face. The very loose idea would be something like: consider the boundary path between every pair of consecutive terminals you want to separate; connect all the vertices on that path to a new vertex, which becomes a terminal for the Steiner tree problem. Now all these Steiner terminals will all lie on the same face. This should be solvable in polynomial time using the algorithm of Erickson et al. (jstor.org/pss/3689922).


Can short-distance connectivity be harder than connectivity?

Has anybody seen the following (or similar) question being considered:

> Can it be **easier** to determine the presence/absence of $s$-$t$ paths than to determine the presence/absence of _short_ $s$-$t$ paths?

A bit more formally, the _distance_ -$k$ _connectivity_ problem STCON(n,k) is, given a subgraph of a complete undirected graph $K_n$ on $[n]=\\{1,\ldots,n\\}$, to decide whether there is a path from node $s=1$ to node $t=n$ of length $\leq k$. By the _length_ , I mean the number of inner nodes (just for notational convenience). The _connectivity_ problem STCON(n) corresponds to the case when $k=n-2$: is there any $s$-$t$ path at all? These problems are monotone boolean functions of $\binom{n}{2}$ variables $x_{i,j}$ corresponding to the edges of $K_n$.

It is well known, that $O(kn^2)$ fanin-$2$ AND and OR gates are enough to compute STCON(n,k). The desired monotone circuit is given by [Bellman-Ford](http://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm): first compute $F_j^{(0)}=x_{s,j}$ for all nodes $j$, and then use the recursion $F_j^{(l+1)}=\bigvee_{i\in[n]} F_i^{(l)}\land x_{i,j}$. Then $F_j^{(l)}$ accepts a given graph iff it has an $s$-$j$ path of length $\leq l$. Hence, $F_n^{(k)}=$STCON(n,k).

> **Question 1:** Can STCON(n) have more than constant times **smaller** monotone circuits than STCON(n,k), for some $k\ll n$?

A boolean function $f(x_1,\ldots,x_n)$ is a _monotone projection_ of a boolean function $g(y_1,\ldots,y_m)$, if the function $f$ can be obtained from $g$ by replacing each $y$-variable by $0$ or $1$ or by some $x$-variable. Say, we trivially have that every THRESHOLD(n,k) is a monotone projection of MAJORITY(2n).

By taking $k$ copies of the input graph for STCON(n,k), one can easily show that STCON(n,k) is a monotone projection of STCON(kn). Thus, STCON(kn) cannot have smaller circuits than STCON(n,k). Can the factor "k" here be replaced by some constant?

> **Question 2:** Is STCON(n,k) a monotone projection of STCON(m) for some $m < kn$?

**ADDDED** (Apr.7 ): Among related results I know are the following:

  1. _STCON and monotone**NC$^1$**_ : if a boolean function $f$ has a monotone formula of size $s$, then $f$ is a monotone projection of STCON(m) for $m=O(s)$; this is easy: just view formulas as parallel-sequential networks. In particular, this implies that _every_ monotone boolean function of $n$ variables _is_ a monotone projection of STCON(m) for some $m\leq n2^n$ (take a monotone DNF).
  2. _STCON itself is not in monotone**NC$^1$**_ : every monotone circuit for STCON(n,k) requires depth about $(\log k)(\log n)$ (independent on circuit size!). This was shown by [Karchmer and Wigderson](http://www.math.ias.edu/~avi/PUBLICATIONS/MYPAPERS/KW90/KW90.pdf). As observed by [Grigni and Sipser](http://www.mathcs.emory.edu/~mic/papers/4.ps), this holds even when AND gates are allowed to have unbounded fanin! If, however, OR gates can have large fanin and AND gates have fanin-$2$, then depth $2\log k$ and size $O(n^3\log k)$ is already enough: repeated squaring of the adjacency matrix $\log k$ times.
  3. _$s$-$t$ Connectivity vs. Connectivity_ : If $f=x_1x_2\lor x_3x_4\lor\cdots\lor x_{n-1}x_n$ is a monotone projection of CONN(m), then $m\geq 2^n+1$. This was proved by [Skyum and Valiant](http://dl.acm.org/citation.cfm?id=3158&CFID=497574256&CFTOKEN=86163804). Here CONN is a "sibling" of STCON: accepts a graph iff it is connected. Note that this particular function $f$ _is_ a monotone projection of STCON(m) even for $m=n$: take a bunch of $n/2$ parallel paths of length two.
  4. _Formulas vs. Circuits_ : If the depth is restricted to $o(\log n)$ then STCON(n,k) requires even non-monotone(!) unbounded fanin _formulas_ of size $n^{\Omega(\log k)}$ for all $k\leq \log\log n$. This was proved by [Rossman](http://eccc.hpi-web.de/report/2013/169/download), and separated for the first time bounded-depth circuits from formulas, because for such values of $k$, repeated squaring gives the desired small (even monotone) _circuit_ of depth $2\log k\leq 2\log\log\log n=o(\log n)$.
  5. _Directed vs. Undirected Connectivity_ : The directed reachability problem DSTCON(n) (where input graphs are directed) is a monotone projection of STCON(m) only if $m=n^{\Theta(\log n)}$. This was proved by [Potechin](http://eccc.hpi-web.de/report/2009/142/revision/1/download), and separated monotone versions of **L** and **NL**.

Does anybody know some results more tightly related to the STCON(n,k) vs. STCON(n) question itself?

* * *

**CORRECTION** (Apr 9): Unfortunately, just taking $k$ copies of the input graph $G$ for STCON(n,k), only shows that STCON(n,k) is a monotone projection of **D** STCON(kn), the **directed** (even acyclic) version of STCON. The difficult direction is to ensure that the modified graph $H=H_G$ has no s-t paths, when $G$ _has_ s-t paths, but all they are longer than $k$. If $H$ is allowed to be directed, this is easy to ensure by arranging the copies of $G$ into $k$ layers, and drawing _directed_ edges between layers according to $G$. But if the edges $H$ are required to be _undirected_ , this simple layering trick won't work. So, I must refine my Question 2 as (cf. with the 5-th result by Potechin above):

> **Question 2':** Is STCON(n,k) a monotone projection of **D** STCON(m) for some $m < kn$?

Both answers would be interesting. If YES, this would show that layering is not the best way to "count". If NO, this would show that every monotone switching network for STCON(n,k) requires $kn$ nodes. (By the Bellman-Ford algorithm - which itself is just the "layering trick" in disguise - $kn$ nodes are also enough.)


Sequences with sublogarithmic concat and approximate split

Is there a data structure for representing sequences that supports the operations:

  * **concat** takes two sequences of size $m$ and $n$ and produces a new sequence of size $m+n$ by joining them in time $o(\lg \min(n,m/n))$ (or $o(\lg \min(m,n/m))$ if $n>m$).
  * For some constants $c$ and $N$, **approximate split** takes a sequence of size $n > N$ and divides it into two contiguous non-overlapping sequences of sizes $p$ and $q$ such that $p+q = n$ and $1/c < p/q < c$ in time $o(\lg n)$
  * **singleton** takes a single element and produces a sequence containing only that element in $O(1)$ time.
  * **linearize** takes a sequence of size $n$ and produces an array of size $n$ containing the elements of the sequence in time $O(n)$.

I'm really looking for worst-case or expected bounds on the time, but amortized bounds would also be interesting. Results in the word RAM would be interesting as well.

Here are some results I am aware of. In this table, **sloppy split** is like approximate split, but the bounds are $1/c < (\lg p)/(\lg q) < c$.

       structure            |           concat           | approx split | sloppy split
    ==================================================================================
    doubly-linked lists     |            O(1)            |     O(n)     |      *
    arrays                  |           O(n+m)           |     O(1)     |      *
    weight balanced trees   |         O(lg (n+m))        |     O(1)     |      *
    treaps and skip lists   |       O(lg min(n,m)) **    |   O(1) **    |     *,**
    functional finger trees |  O(min(lg lg m/n, lg lg n) |   O(lg n)    |     O(1)

    *: same as approx split
    **: expected

By functional finger trees I mean "[Purely functional representations of catenable sorted lists](http://www.math.tau.ac.il/~haimk/papers/loglog23.ps)" by Kaplan and Tarjan.


Linear-time algorithm to test if clique number equals degeneracy bound?

Given a connected simple graph $G=(V,E)$, let $d$ denote its [degeneracy](https://en.wikipedia.org/wiki/Degeneracy_\(graph_theory\)) and let $\omega$ denote the size of a [maximum clique](https://en.wikipedia.org/wiki/Clique_problem).

A well-known bound on the clique number is $\omega\le d+1$, which is helpful when solving the maximum clique problem or when [enumerating all maximal cliques](https://dl.acm.org/doi/abs/10.1145/2543629?casa_token=fxzBWpiA1ZsAAAAA:CrMNWZ-0GU9DU3L0-UE43AniI2H-2gvXWFzx341kOOA8MvUU2QnCVAQUxcpoQQGtfriWot8YZGi9TA).

How fast can one test whether this bound is tight, $\omega=d+1$? An algorithm that runs in time $O(dm)=O(m^{1.5})$ is [known](https://pubsonline.informs.org/doi/10.1287/opre.2019.1970).

Is there a faster algorithm, say, running in linear time?

Or, is $O(m^{1.5})$ best possible under something like [SETH](https://en.wikipedia.org/wiki/Exponential_time_hypothesis)?

Maybe you are aware, but this problem recently appeared in codeforces codeforces.com/contest/1439/problem/B. It seems nobody in the discussion mentions anything better than $O(m^{1.5})$.

Um...it looks like their article was just published and they list your question as Open Problem 1 (minus the possible connection to SETH)...

Ah, I see now. (After your comment, I thought I could answer your Q, but then looked at the article and saw I just rediscovered their algorithm in the case $p=0$.) I wonder if you don't even need SETH - it seems like maybe it's possible to show that if you could do better than $O((m+n) + d^2 n)$ (which is what they have) then either you'd be able to compute $k$-cores faster than linear (not possible by query complexity) or test whether a $d$-vertex graph is a clique in $o(d^2)$ (also not possible by query complexity). I don't quite see a reduction, but maybe one can do it w/o SETH...

The decomposition is linear time, but I don’t think that solves the problem. It works, for example, for G=C_3 or G=C_4 but fails for their disjoint union (or for their disjoint union with an added edge between them).

Can't you just compute the k-core decomposition (which is quasilinear time IIRC), and then just check if the last core is a clique?


Is it possible to boost the error probability of a Consensus protocol over dynamic network?

Consider the binary consensus problem in a synchronous setting over dynamic network (thus, there are $n$ nodes, and some of them are connected by edges that may change round to round). Given a randomized $\delta$-error Monte Carlo protocol for Consensus in this setting, is it possible to use this protocol as a black box to obtain another Consensus protocol with smaller error?

Note that for problems with deterministic outcome (such as Sum), this can be done by repeatedly executing the protocol and taking the majority as the answer. However I am unable to figure out how for Consensus, so I wonder whether this is actually impossible to do.

\--- Details ---

**Dynamic Network.** There are $n$ nodes on a dynamic network over synchronous setting (thus the protocol will proceed in rounds). Each node has a unique ID of size $\log(n)$. There are edges connecting pairs of nodes, and this set of edges may change from round to round (but remains fixed throughout any particular round). There may be additional restrictions to the dynamic network that allows the problem to be solved by some protocol (such as having a fixed diameter), but it is irrelevant to our discussion.

The only information known to each node is their unique ID. They do not know $n$ or the topology of the network. In particular, they do not know who their neighbors are in the current round (neighbors are nodes that are adjacent to them with an edge). The only way to figure out the neighbors is after receiving messages from them.

**How nodes communicate.** The only method of communication between nodes is by broadcasting messages under the $CONGEST$ model (D. Peleg, "Distributed Computing, A Locality-Sensitive Approach"). More specifically, in each round, every node may broadcast an $O(\log n)$ sized message. Then, every node will receive ALL messages that were broadcasted by all of its neighbors in that particular round in an arbitrary order. In particular, nodes may attach their IDs onto their messages, since their IDs are of size $O(\log n)$.

**Binary Consensus.** The binary consensus problem over this network is as follows. Each node has a binary input ($0$ or $1$), and each must decide either $0$ or $1$ under the the validity, termination, and agreement for consensus with $\delta$ error:

  * validity means that for $z \in \\{0, 1\\}$, if all nodes have $z$ as its initial input, then the only possible decision is $z$.

  * termination means that each node must eventually decide.

  * agreement means that all nodes must have the same decision.

  * The error rate means that under worst case input and worst case network, the probability that the protocol does not satisfy any of the three conditions is at most $\delta$ over average coin flips of the protocol's coin.

**Question.** For a particular set of dynamic networks, suppose we have a lower bound on the average number of rounds incurred by any randomized $\delta$-error protocol $P$ for solving binary consensus under this settings such that $\delta < \frac{1}{3}$, under worst case dynamic network from this set, worst case nodes' inputs, and on average coin flips of the protocol. Does this bound automatically hold for any $\delta'$-error protocol for $\delta < \delta' < \frac{1}{3}$?.

@Peter Also this question is more of a whether it is possible to obtain a better protocol using a black box protocol. For example, in Sum, each node can run the protocol multiple times (either in parallel or in a row) and takes a majority. Using Chernoff's bound, for any $0 < \delta' < \delta < \frac{1}{3}$, one can obtain protocol with $\delta'$ error from a $\delta$ error protocol for Sum by executing the protocol a constant amount of time and taking a majority as the answer.

@Peter No unless your protocol is specifically designed to be able to do that. The only way for the nodes to communicate is through broadcasting and receiving messages. E.g., the lack of message from a particular node may mean something. There are no "magical" communication channels otherwise.

Do you assume that, when an instance of your blackbox consensus algorithm fails, all nodes are aware that the consensus algorithm has failed? This seems to depend on the precise properties of the dynamic network that you're assuming...

suggest try to fit it into the following framework. The Consensus Problem in Unreliable Distributed Systems (A Brief Survey) (2000) / Fisher. there are some impossibility results known & could your idea possibly violate any?

@vzn No, I'm not really familiar with this topic. Thus I thought that this question is well-known, and I was hoping for a quick answer here. Seems like this is not well-known then. I wasn't aware of the TCS stackexchange before, I'll try to ask the admin to cross post this question there.

are you familiar with Paxos, "a family of protocols for solving consensus in a network of unreliable processors"? does it not match the requirements for some reason? there are many (standard) consensus protocols, can you give an example of a "randomized δ-error protocol for Consensus"?

it appears research level to me! the whole question seems to be built on a research framework! seriously consider Theoretical Computer Science! can you define "randomized δ-error protocol"? try also Theoretical Computer Science Chat


complexity of checking if a subspace is a Euclidean section of L1

If $X$ is a linear subspace of ${\mathbb R}^n$, $X$ is high-dimensional, and for every $x\in X$ we have

$(1-\epsilon) \sqrt n ||x||_2 \leq ||x||_1 \leq \sqrt n ||x||_2$

for some small $\epsilon >0$, then we say that $X$ is an almost-Euclidean section of $\ell_1^n$, and (the matrix whose image is) X is useful in compressed sensing. A random subspace works excellently, and there is a huge research program devoted to the **explicit construction** of such spaces.

Is it known what is the complexity of approximating the "Euclidan-sectionness" of $X$? That is, given a subspace $X$, say presented via a basis, consider the problem of finding the unit (in $\ell_2$ norm) vector in $X$ of smallest $\ell_1$ norm.

> What is the complexity of this problem? Are hardness of approximation results known?

Apart from specific applications, these seem to be interesting problems. Is it known what is the complexity of finding the vector of **maximum** $\ell_1$ norm among the unit vectors of a given subspace?

This is not an answer to your question.  But in the vein of computational problems arising from compressed sensing applications, Koiran and Zouzias have a recent paper on checking whether a matrix satisfies the restricted isoperimetry property (RIP) and related problems.

Thanks Sariel, I had inverted the places of $\ell_1$ and $\ell_2$. (If you want $\ell_2$ in the middle, then it should be $||x||_1/\sqrt n \leq ||x||_2 \leq (1+\epsilon)||x||_1 / \sqrt n$, because it's always $||x||_1 \leq \sqrt n ||x||_2$.)

The above inequality is slightly wrong. You probably mean that $(1-\varepsilon)||x||_1 /\sqrt{n} \leq ||x||_2 \leq ||x||_1/\sqrt{n}$. Indeed, for any $x$, $||x||_1 \geq ||x||_2$.


Looking for an operator on polynomials

I have a small, self-contained, math question, whose motivation is from theoretical computer science (specifically, list decoding of algebraic codes, derivative/multiplicity codes, etc). I wonder whether someone might have an idea.

I'm looking for an operator T that can be applied to m-variate polynomials over a finite field. When applied to a polynomial, the operator should yield a polynomial of not much higher degree. The operator should satisfy the following property: for every m-variate polynomial $F$, and m univariate non-constant polynomials $g_1,...,g_m$, if you know $g_1,...,g_m$ and $F(g_1(t),...,g_m(t))$ for a parameter t, then you can also compute $TF(g_1(t),...,g_m(t))$. The operator should be non-trivial, in the sense that for a fixing $x_1,..,x_m$, the value $F(x_1,...,x_m)$ does not determine the value of $TF(x_1,...,x_m)$.

For $m=1$, the derivative operator gives exactly that: By the chain rule $(F(g(t)))' = F'(g(t))\cdot g'(t)$, which implies that $F'(g(t)) = (F(g(t)))'/g'(t)$. My question is whether there is an operator that works for general m.

Honestly, I asked this question so long ago, I only barely remember what I needed it for :-)... I believe that the issue is that multiplying by a fixed polynomial is "trivial" in the sense that to compute the multiplication at a point, you only need to know the value of F at the point (and nothing about F's inner-workings).

Dana, I may be missing something, what about $TF(x_1,...,x_n) = T(x_1,...,x_n) P(x_1, ..., x_n)$, where $P$ is some multivariate polynomial?

F(g(t))' and g'(t) are formal polynomials in t. You can divide the formal polynomials.

Suppose $g(t) = t^2$. You still can't evaluate $F'$ at 0? (I understand that you want point-wise evaluation)

If g' is identically zero then you can't expect anything (I'll edit the question to specify the g_i's are not identically zero).

Your example in one dimensional case is not flawless. What if $g'(t)=0$ ?

Suppose you take $TF(g_1(t),..,g_m(t)) = \sum_{i=1}^{m} g_i'(t) dF(x_1,...,x_m)/dx_i$ (known as the total derivative). How you do compute $dF(x_1,...,x_m)/dx_i$ from $F(g_1(t),...,g_m(t))$?

Why total derivative wouldn't fit your requirements?


When does adding edges decrease the cover time of a graph?

When first learning about random walks on a graph $G$, one may have an intuitive feeling that adding edges to $G$ will decrease its cover time $C(G)$. However, this is not the case. The [path graph](https://en.wikipedia.org/wiki/Path_graph) $P_n$ has cover time $C(P_n) = \Theta(n^2)$ while the [($\frac{n}{2}$, $\frac{n}{2}$)-lollipop graph](http://mathworld.wolfram.com/LollipopGraph.html) $L_{\frac{n}{2}, \frac{n}{2}}$ has cover time $C(L_{\frac{n}{2}, \frac{n}{2}}) = \Theta(n^3)$. Eventually adding edges does decrease the cover time because the complete graph $K_n$ has cover time $C(K_n) = \Theta(n \log n)$ by analogy to the [coupon collector problem](https://en.wikipedia.org/wiki/Coupon_collector%27s_problem).

Under what assumptions though would the supposed intuition hold true? Specifically, what about [vertex transitivity](https://en.wikipedia.org/wiki/Vertex-transitive_graph)?

> Let $G$ be a vertex-transitive graph with $n$ vertices. Consider any vertex-transitive graph $G^+$ obtained from $G$ by adding edges (i.e. both $G$ and $G^+$ are vertex transitive and $G$ is a spanning subgraph of $G^+$).
>
> Is it the case that $C(G^+) \le C(G)$?

My bad, I confused spanning with induced.

@chazisop Those subgraphs are not spanning.

Wouldn't the complete graph $K_{n}$ and any of its subgraphs $K_{k}$, $k < n$ be a counterexample for general vertex transitivity?


Complexity of approximating the range of a matrix

Given an $m$ by $n$ matrix $M$ with $m \leq n$ and elements from $\\{-1,1\\}$, let us define:

$$S_M = |\\{Mx : x \in \\{-1,1\\}^n\\}|.$$

I believe that it is NP-hard to compute $S_M$ exactly, by applying the reductions from [Decide whether a matrix's kernel contains any non-zero vector all of whose entries are -1, 0, or 1](https://cstheory.stackexchange.com/questions/20277/decide-whether-a-matrixs-kernel-contains-any-non-zero-vector-all-of-whose-entri) to the following decision problem: does $S_M = 2^n$?

> Is it possible to approximate $S_M$ to within a constant factor in polynomial time? If not, what is the best one can do in polynomial time?

[Cross-posted to <https://mathoverflow.net/questions/229852/complexity-of-approximating-the-size-of-the-range-of-a-matrix> ]

(1) If there is a poly-time $2^{n^{1-\epsilon}}$-approximation for any $\epsilon>0$, then there is a poly-time $(1+1/q(n))$-approximation for any polynomial $q$.  To see this, given $M$, consider the block-diagonal matrix $M(k)$ formed by $k$ independent copies of $M$ along the diagonal, so $S_M=(S_{M(k)})^{1/k}$. Take $k=(n q(n))^{1/\delta}$. If $x$ is a $2^{(nk)^{1-\epsilon}}$-approximation of $S_{M(k)}$, then $x^{1/k}$ is a $(1+1/q(n))$-approximation of $S(M)$. (2) One has $2^k\le S_M\le 2^n$ where $k$ is the rank of $M$, but this doesn't help as $S_M$ can be large even when $k=m=1$.


Intersecting Complexity Classes with Advice

In [on hiding information from an oracle](http://linkinghub.elsevier.com/retrieve/pii/0022000089900184), the authors (Abadi, Feigenbaum, and Kilian) wrote:

> $(\mathsf{NP/poly} \cap \mathsf{co\text-NP}{/poly})$ ... is **not known** to be equal to $(\mathsf{NP} ∩ \mathsf{co\text-NP}){/poly}$.

They highlighted that in the conference paper, they mistook the two classes. Apparently, the latter is a subset of the former, but we don't know if the containment is strict.

Assuming $X$ and $Y$ are complexity classes, and $F$ is a set of functions specifying the length of the advice strings, are there recent results comparing $(X_{/F} \cap Y_{/F})$ and $(X \cap Y)_{/F}$, resolving issues like the one pointed above?

@HenryYuen: I think that a Language $L$ is in $(NP \cap coNP)/poly$ iff there is a language $K$ in $NP \cap coNP$ and $a_i$ advice of polynomial length s.t. $x \in L$ iff $(x, a_{|x|}) \in K$.

@HenryYuen: Oh, I got your point. Strangely, the definition of (NP ∩ coNP)/poly in Complexity Zoo (qwiki.stanford.edu/index.php/Complexity_Zoo:N#npiconppoly) does not mention machines with advice, but "languages" with advice. However, quoting from An Oracle's Builder Toolkit: "NP ∩ coNP is defined by the enumeration $M_1,M_2,\ldots$, where $M_i$ with $i = \langle i_1,i_2 \rangle$ is the pair of non-deterministic oracle Turing machines $N_{i_1}$ and $N_{i_2}$ such that both machines run in time $n^i$..." (Read page 27 for more info)

The reason I ask about the computational model is because I don't know what (NP ∩ coNP)/poly means. NP/poly is the set of languages that are accepted by NP machines with polynomial amount of advice. Presumably, (NP ∩ coNP)/poly is the set of languages accepted by (NP ∩ coNP) machines with polynomial advice -- or is there another definition that isn't machine-definition-dependent?

@HenryYuen: I actually don't know if there's an underlying model of computation, but the definitions of complexity classes are clear, as in the case of ZPP. Besides being a very interesting problem, is there any significance (to my question) if NP ∩ coNP does (or does NOT) admit a computation model?

If you take the definition that ZPP = RP ∩ coRP, that doesn't immediately give you a model of computation that accepts only ZPP languages: it only says that every language in ZPP has both an RP machine and a coRP machine (which is well defined). You have to prove that ZPP is the class of languages that admit Las Vegas algorithms. Similarly -- NP ∩ coNP defines a set of languages that have both NP and coNP machines, but is there a model of computation that accepts precisely NP ∩ coNP?

@HenryYuen: Maybe the definition of ZPP helps: ZP = RP ∩ CoRP. See en.wikipedia.org/wiki/ZPP_(complexity)#Intersection_definition.

What is the definition of (NP ∩ coNP)/poly? What is a NP ∩ coNP machine?


Intermediate problems between PSPACE and EXPTIME

Intermediate problems between P and NP are quite famous, and are sometimes considered as complexity classes by themselves.

Do you know of any problem that is known to be PSPACE-hard and in EXPTIME, and resisting all efforts to be proved complete for one of these classes ?

Lifted (succinct) versions of problems between LOGSPACE and PTIME are accepted, but even more interesting would be problems that are not of this form.

Here are some I found, this area of complexity theory seems to be the realm of games:

  * Phutball: <https://arxiv.org/abs/0804.1777>
  * Go (with Chinese rules): D. Lichtenstein and M. Sipser, Go is polynomial-space hard

I think the more correct way of stating the question is asking for candidate problems in ExpTime - PSpace - ExpTime-hard. Note that e.g. in the case of P vs. NP we don't know if Factoring or GI is P-hard.


Mutual information vs. Product sets

Suppose we have two _dependent_ random variables $X$ and $Y$, each of which is uniform over $\\{0,1\\}^n$, such that their mutual information $I(X;Y)$ is small, say, at most $\sqrt{n}$. Does this imply that there exist large sets $\mathcal{X}, \mathcal{Y} \subset \\{0,1\\}^n$ such that the product set $\mathcal{X} \times \mathcal{Y}$ is contained in the support of the distribution $(X,Y)$?

A variant of this question can be phrased in graph-theoretic terms: Suppose we have a sufficiently dense bipartite graph G. Does this imply that $G$ contains a large complete sub-graph $G'$? (i.e., $G'$ is required to be a complete bipartite graph with bi-partition $(A,B)$ such that $A$ and $B$ are relatively dense in the corresponding parts of $G$)

If $(X,Y)$ is a product of iid trials $(X_i,Y_i)$ then I am inclined to say yes.

If my calculation is correct, a standard use of the probabilistic method shows that for sufficiently large N, there exists a bipartite graph on N+N vertices with at least (1/2)N^2 edges that does not contain K_{k,k} as a subgraph, where k = floor(2.001 lg N).  (“lg” denotes the logarithm to base two.)

I'm not an expert, but perhaps this paper on Ramsey theory applied to bipartite graphs can help you: math.mit.edu/~fox/paper-density-theorems-final.pdf


Computability of a "weird" set

The starting point of this question is the observation that the smallest positive integers $a,b,c$ satisfying

$$\frac{a}{b+c} + \frac{b}{a+c} + \frac{c}{a+b} = 4$$

are [absurdly high](https://plus.google.com/+johncbaez999/posts/Pr8LgYYxvbM). This leads to the following general question: Is the set $C\subseteq {\mathbb N}$ defined by $$ C = \left\\{n\in\mathbb{N}\setminus\\{0\\}: \big(\exists a,b,c \in\mathbb{N}\setminus\\{0\\}\big):\frac{a}{b+c} + \frac{b}{a+c} + \frac{c}{a+b} = n\right\\}$$ computable?

I'm not an expert, but if you simplify the equation you get a cubic diophantine equation in three variables, and I think it's an open problem if universality can be achieved in such a setting. In every case, quadratic diophantine equations in two variables ($ax^2 + by + c = 0$) are already NP-complete (see NP-complete decision problems for quadratic polynomials) ... so I'm not surprised if switching to cubic+three vars leads to very hard instances (outside NP).


Can a Penrose tile cellular automaton be Turing-complete?

This question was based on an incorrect premise ... see Colin's comment below. Forget it.

This was inspired by the discussion on [this Math Overflow question](https://mathoverflow.net/questions/45378/undecidability-in-conways-game-of-life/45382). First, I need to define our terms.

In a Penrose tiling, there are generally several different legal patterns of tiles which will cover a given region. A Penrose tile cellular automaton should be some rule that deterministically takes a Penrose tiling $T$ to a Penrose tiling $T'$, where each tile in $T'$ is deterministically given by looking at the tiles in a radius $r$ around the corresponding spot in $T$. You should be able to implement these by having a set of rules of the form: when a region of shape $S$ is covered by a pattern $X$ of tiles, replace it with a pattern $Y$ of tiles. In order to do this deterministically, you either have to make sure no two of your replaceable regions can overlap or have some priority ranking on these replacement rules. But certainly you can ensure this, and define lots of different Penrose tiling cellular automata.

What does it mean for a Penrose tiling celluar automaton to be Turing-complete. Here's what I think it should mean (although I won't insist on it in the answers): the halting problem should be reducible to the behavior of such an automaton. Let's take some canonical Penrose tiling $T_0$ that provides constraints on our starting position. We start with an input $G$ to a universal Turing machine, and we'd like to decide whether the machine halts on input $G$. I would like some computable map from $G$ to a starting Penrose tiling $S$ such that $S$ differs from $T_0$ on only a finite set of tiles. We then run the Penrose tiling cellular automaton, starting with $S$, and wait for some finite canonical configuration $C$ at position $0$ in the Penrose tiling. I want configuration $C$ to appear at position $0$ if and only if the universal Turing machine halts on input $G$.

The strange thing about Penrose tiling cellular automata is that every finite legal configuration of tiles appears infinitely often in every Penrose tiling of the plane. Thus, our universal Penrose tiling is not only computing the behavior of our universal Turing machine on input $G$, it's also simultaneously carrying out the first steps of every other possible computation. This makes me doubt whether Penrose tiling cellular automata could be Turing complete. On the other hand, if they're not Turing complete, what is the class of computations that Penrose tiling cellular automata can perform?

Yes, that is true for tilings formed via the deflation process. But an arbitrary planar tiling might have a "rift" along a line in the plane, along which the higher level tiles do not match up (like a tiling of the plane by squares in which the upper half plane is shifted right by a fraction of a unit). This is certainly possible with Robinson tiles and Ammann tiles, and I would expect it also for the various Penrose tiles although I haven't checked. If rifts can occur, local patches along the rift will appear infinitely often in the same tiling but needn't appear in another tiling.

@Matt: What I should have said is that every finite pattern that appears once in an infinite Penrose tiling appears infinitely often in every Penrose tiling.

If every finite pattern would occur, you would not be able to "get stuck" when attempting to tile the plane (because your finite pattern, whatever it is so far, would be guaranteed to be part of a valid tiling of the plane).  But in fact, you do need to know what you are doing in order to not get stuck, regardless of which Penrose tile set you are talking about.  Only very occasionally do you really have a choice of what tile to place (in the sense that either tile would be ok for creating a full tiling of the plane), approximately once per inflation scale level.

Yes, it's 14 years later, but I can't help noticing that something is wrong on the internet (like the xkcd cartoon). It is not correct that every finite pattern occurs in a Penrose tiling.

@Peter: This question intrigued me because it seems related to one of the main open problems in tile self-assembly, which is "the power of multiple nucleation." If the Penrose tiling rule were somehow limited to radiate out one tile at a stage from the origin, instead of everywhere being tileable at once, I think the model would be very close to self-assembly models. The open questions there are complexity-related, not computability, e.g.: is there a finite shape such a restricted Penrose tiling could achieve that a GCA could not achieve with only polynomial complexity increase?

@Colin, Actually, I was wrong about this. Forget the question. Maybe I should delete it.

Can you give an example of a region which may be legally covered by different patterns of tiles? I'm not familiar with the subject, but there is a unique way to break up a triangle into smaller triangles in "up-down" generation - see for example Prop 6.1 of Quasicrystals and geometry.

If someone reduced the Turing Machine Immortality Problem to a Penrose CA, would that be progress?  (TMIP = given a TM with an input tape with infinitely many nonblank symbols on it, does it halt?)  That problem is undecidable for TMs.

I don't think the existence of every finite pattern is any evidence against Turing completeness - in the game of life it seems plausible that there is a (finite) initial state that runs every turing machine G and puts a "halt" marker at some position f(G) if and only if G halts.

I hope it's clearer now. I want the rules to be deterministic and local, but exactly how they're formulated is less imporant.

Okay, second round.  There are Generalized Cellular Automata, where each cell $x$ transitions based on a "stencil" $\delta_x$, which is a neighborhood of tiles around $x$, and the size and shape of these neighborhoods may vary from cell $x$ to cell $y$. Is a Penrose CA a generalization of GCA's, where now each $x$ has a stencil set $S$ (perhaps common to all cells) and some $\delta \subseteq S$ can be applied to $x$ and its surrounding cells? This then leads to multiple possible tilings of the plane for a single start state. Does every ("nice"?) start state converge to a stable tiling?

The replacement rules are indeed connected templates of finite size. The problem with your periodic "halting" state is that it can't happen. You always can find any specific finite pattern in a Penrose tiling, so if any Penrose tiling CA has a starting state that is eventually periodic, then any starting state for that Penrose tiling CA is periodic with that period.

I am confused by your definition, sorry.  Is a Penrose CA just like a normal (2D) CA, except that the replacement rules are connected templates of finite size, instead of a local transition function that is applied cell by cell?  So there's an initial configuration at time step 0 that specifies the input, and the connected templates specify the program? One way small models of computation specify "halting" is to repeat a special state infinitely often. So maybe if the simulated TM halts the Penrose CA keeps recreating a certain pattern, and if the TM runs forever, anything goes.


NP-Hardness of 4-cycle packing problem in complete bipartite digraph?

A directed complete bipartite graph is a bipartite graph where there is exactly one directed edge between any two vertices from its two different parts. In other words, it's an orientation of a complete bipartite graph.

Given a directed complete bipartite graph, we are asked to find the largest set of edge-disjoint 4-cycles. Note that these 4-cycles can share node(s).

Is this problem NP-Hard? I tried to reduce from 2P2N-3SAT to this problem, but failed. On the other hand, I found no polynomial algorithm could solve it optimally.


Is there a P-complete language X such that succinct-X is in P?

I came across a paper called "A Note on Succinct Representation of Graphs". It seems that in the discussion section they claim that for any problem $X$ that is $\mathrm{P}$-hard under projections, $\mbox{succinct-X}$ is $\mathrm{EXP}$-hard.

This made me wonder if the theorem fails for more complicated kinds of reductions. This led me to the following.

> **My Question**
>
> Are there any problems $X$ such that $X$ is $\mathrm{P}$-complete under logspace reductions and $\mbox{succinct-X}$ is in $\mathrm{P}$?

**Additional Questions:**

(1) If this is an open problem, then what are the implications if such an $X$ existed?

(2) If this is an open problem, is it still open is we weaken the requirement to $\mbox{succinct-X}$ in $PH$?

(3) It seems that such an $X$ would also satisfy that $X$ is $\mathrm{P}$-hard under logspace reductions, but not $\mathrm{P}$-hard under projections. Are such problems known to exist?

(4) I might be mistaken, but I think that I have a construction for such an $X$ assuming that $NP = L$. Would this be interesting?

**Note:** I'm still learning about projections so please let me know if I made any mistakes. Thank you!

Werent p-projections used in Valiants' original completeness and algebra paper?

@EmilJeřábek Yes, I noticed this too.  :)

Seeing that projections are a restricted class of polylogtime reductions, let me add that what I wrote above about logtime reductions also applies to polylogtime reductions.

@EmilJeřábek Thank you for the clarification!  I really appreciate it.

Yes, that's it. (Note that logtime Turing machines are defined so that they receive input by means of a query tape that requests individual bits instead of the usual input tape, hence they readily take input represented by a circuit.) For pspace-succinct-$X$, one can take a variant of succinct-$X$ where the input is not represented by an ordinary Boolean circuit, but by a quantified Boolean formula (or circuit).

@MichaëlCadilhac Thanks Michaël!  I appreciate the helpful suggestions.  :)

@user3483902 Thank you very much for the good questions!  I'm still learning about projections so I think it's best if I refer you to a reference that includes a definition for time bounded projections: theoryofcomputing.org/articles/v013a004

@EmilJeřábek In regards to the second part of your comment, did you mean the following?  If $X$ is $P$-complete under logspace reductions, it doesn't necessarily mean that $\mbox{succinct-X}$ is $EXP$-hard.  But, $\mbox{pspace-succinct-X}$ would be $EXP$-hard where $\mbox{pspace-succinct}$ is a more powerful notion of succinctness (that we haven't formally defined) that offers a higher compression ratio in some cases.

@EmilJeřábek Now, although $x$ has length $n$ and $pad$-$x$ has length $2^n$, $pad$-$x$ can be encoded as a circuit of size $n$.  Further, because $r$ is in dlogtime, it can be represented by a circuit of size $n^2$ on inputs of size $2^n$.  And, it seems that we can somehow combine these two circuits to get a circuit $c$ of size roughly $n^3$ that encodes $\mbox{r(pad-x)}$ so that $x \in L$ iff $c \in \mbox{succinct-X}$.

@EmilJeřábek Thanks for the helpful comment!  So if I understand the first part correctly, the proof would go something like this? Given a language $X$ that is $P$-complete under dlogtime reductions and a language $L$ in $DTIME(2^n)$.  Consider padding $L$ to get a language $pad$-$L$.  Since $pad$-$L$ is in $P$, there is a dlogtime reduction $r$ from $pad$-$L$ to $X$.  We have that for every input string $x$, $x \in L$ iff $pad$-$x \in pad$-$L$ iff $\mbox{r(pad-x)} \in X$.

A simple padding argument shows that if $X$ is P-complete under dlogtime reductions, then succinct-$X$ is EXP-complete (in fact, still under dlogtime reductions). I thought at first this would generalize to less restrictive notions of reductions so that, e.g., P-completeness of $X$ under logspace reductions would imply  EXP-completess of succinct-$X$ under PSPACE reductions, but it does not seem to work that way; rather, it gives the EXP-completeness under polytime (or even more efficient) reductions of "PSPACE-succinct" $X$, if you get what I mean by that.

what is a "projection" , does it pertain to reductions only - reductions with  logspace requirements have this property, or something that imposes succintness to the representation?

My 2¢ here: Question 3 certainly looks like a prerequisite, so it may be worth asking separately.  If this doesn't get an answer, you may want to contact P-hardness specialists such as P. McKenzie.


Fourier spectrum of the parity of two monotone Boolean functions

This is a question that I've been pondering, on and off, for a while, and unsuccessfully. I'd be very interested in any insight regarding this conjecture. (Or rather, these conjectures.)

Recall that, given a Boolean function $f\colon \\{-1,1\\}^n \to \\{-1,1\\}$, the Kahn—Kalai—Linial theorem states that $$\max_{i\in[n]} \operatorname{Inf}_i f \geq \operatorname{Var}[f]\cdot \Omega\\!\left(\frac{\log n}{n}\right) \tag{1} $$ from which we get that, for any _monotone_ Boolean function $f\colon \\{-1,1\\}^n \to \\{-1,1\\}$, $$\max_{i\in[n]} \widehat{f}(i) \geq \operatorname{Var}[f]\cdot \Omega\\!\left(\frac{\log n}{n}\right) = (1-\widehat{f}(0)^2)\cdot \Omega\\!\left(\frac{\log n}{n}\right) \tag{2} $$ (writing $\widehat{f}(i)$ for $\widehat{f}(\\{i\\})$, $i\in\\{0,\dots,n\\}$). Moreover, (2) is tight, as shown by considering the $\textsf{Tribes}_n$ function. In particular, this implies that $$ W^{(0)}[f]+W^{(1)}[f] = \sum_{i=0}^n \widehat{f}(i)^2 = \Omega\\!\left(\frac{\log^2 n}{n^2}\right) \tag{3} $$ for any monotone Boolean function $f\colon \\{-1,1\\}^n \to \\{-1,1\\}$, where $W^{(k)}[f] \stackrel{\rm def}{=} \sum_{S: \lvert S\rvert =k} \widehat{f}(S)^2$.

Now, consider _two_ monotone Boolean functions $f,g\colon \\{-1,1\\}^n \to \\{-1,1\\}$, and let $h\stackrel{\rm def}{=}fg$ be their parity. It is easy to see that we could have $W^{(0)}[h]+W^{(1)}[h]=0$, e.g. by considering $f,g$ to be two different dictator functions (but in that very specific case, $W^{(2)}[h]=1$). _But must there be some non-negligible Fourier mass on the first 3 Fourier levels, then?_

> What can we say about $W^{(0)}[h]+W^{(1)}[h]+W^{(2)}[h] = \sum_{S: \lvert S\rvert \leq 2} \widehat{h}(S)^2$?

**Conjecture 1.** For any two monotone Boolean functions $f,g\colon \\{-1,1\\}^n \to \\{-1,1\\}$, one must have $W^{(0)}[fg]+W^{(1)}[fg]+W^{(2)}[fg] > 0$.

Actually, I'd be actually inclined to believe the following stronger statement:

**Conjecture 2.** For any two monotone Boolean functions $f,g\colon \\{-1,1\\}^n \to \\{-1,1\\}$, one must have $W^{(0)}[fg]+W^{(1)}[fg]+W^{(2)}[fg] \geq \frac{1}{\operatorname{poly}(n)}$.

_Side note:_ this would have implications about _weak learning_ of the class of "2-monotone" functions, which are exactly those functions obtained as parity or anti-parity of $2$ monotone functions. (See e.g. [BCOST15].) But more importantly, this is a very simple-looking question, that has been nagging at me for way too long.

* * *

[BCOST15] Eric Blais, Clément L. Canonne, Igor Carboni Oliveira, Rocco A. Servedio, Li-Yang Tan. _Learning Circuits with few Negations._ APPROX-RANDOM 2015: 512-527

@daniello As far as I can tell, not much, at least in terms of blackbox interpretation of the results. The question above would have applications to weak learning (learning to advantage $1/2+1/\mathrm{poly}(n)$), while the paper you link shows lower bound on testing (and a relaxation, parameterized testing). As far as I am aware, there is no direct connection between the two (the general connection is "(strong) learning implies testing").

Can you shed some light on what arxiv.org/pdf/1705.04205.pdf means for this question?


Is it possible to find the median with a linear size sorting network?

Is there a sorting network that makes only $O(n)$ comparisons and finds the median?

The AKS sorting network sorts with $O(\log n)$ parallel steps, but here I am only interested in the number of comparisons. The median of medians algorithm finds the median with $O(n)$ comparisons, but it cannot be implemented as a sorting network.

Remark. In fact, in a recent work, we needed a version that is less powerful than pairwise comparison and resembles sorting networks. In our model one could input two elements, $a$ and $b$, and the output was either "a" or "b", such that the output is at least as big as the other number. (In case of equality, either one of them, and we are interested in worst case complexity.) In this variant we could prove that there is a solution with $O(n)$ comparisons. Of course I am also interested if anyone knows anything about this model ever being studied.

Actually the comparator circuit model is a bit different, since you are allowed to repeat inputs and their negations. What you are looking for is a comparator network for majority.

@Yuval Your result seems to be the only hit on google for "comparator circuit complexity" and even there I cannot see the definition as the minimum number of gates needed, but I suppose you mean the same thing as I do.

Equivalently, you are asking what is the comparator circuit complexity of (Boolean) majority.


Exponential-time factorization of polynomials

Let an _explicit_ field be a field for which equality is decidable (in some standard model of computation). I am interested in the factorization of univariate polynomials over an explicit field.

It is known that over some explicit fields, testing irreducibility of polynomials is undecidable [1]. Though, over many fields, the irreducible factorization of polynomials is known to be computable in polynomial time, either deterministically (over $\mathbb Q$ [2] or any number field) or probabilistically (over finite fields [3]). Here the size of the input is the size of the _dense representation_ of the polynomial, that is the list of all its coefficients.

> Is there an explicit field for which
>
>   * either the best known algorithm has an exponential running time,
>   * or (better) there exists an exponential lower bound for irreducibility testing?
>

**Quick clarification:** There may be very different _explicit fields_ , depending on the complexity (for instance) on the equality test or of the standard operations (addition, multiplication). Actually, I am not aware of any result about polynomial factorization which is not a polynomial time upper bound, or undecidability. So I am interested in any kind of different result (exponential time is just an example). Conditional lower bounds are of interest too.

**References.**

[1] A. Fröhlich et J. C. Shepherdson (1955): [On the factorisation of polynomials in a finite number of steps](http://dx.doi.org/10.1007/BF01180640).
[2] A. K. Lenstra, H. W. Lenstra Jr., L. Lovász (1982): [Factoring polynomials with rational coefficients](http://dx.doi.org/10.1007/BF01457454).
[3] E.R. Berlekamp (1967): [Factoring Polynomials Over Finite Fields](http://www3.alcatel-lucent.com/bstj/vol46-1967/articles/bstj46-8-1853.pdf).

Thanks @JoshuaGrochow! I found the paper incredibly easy to read, even though my German lessons are quite old now...

Depending on your definition of "explicit field", the result you cite as [1] was also proven by van der Waerden much earlier (1930). Amazingly, he proved this before the notion of computability had been formally defined! See: ams.org/mathscinet-getitem?mr=1512605

I was aware while writing my question that some this question should be addressed. Actually, I am interested in both cases. I would be very much interested by the implication to ETH you mention. In other words, I am also interested in conditional lower bounds.

What do you mean by "explicit field" ? Are the operations is the field given by oracles or by algorithms ? I am asking because if the field's operations are given by efficient algorithms proving an exponential lower bound for factoring seems to imply of proof of ETH.


Pseudorandom functions in ACC^0?

In the lower bound result by Ryan Williams (Non-uniform $\mathsf{ACC}$ circuit lower bounds), there is a mention of "little evidence that Pseudorandom function generators exist in $\mathsf{ACC}^0$. Is there any development in this regard that might be of interest? (Even old results implying something along these lines will be great.)

The following paper doesn't answer your question but does show somewhat simpler candidate PRFs ccs.neu.edu/home/viola/papers/spn.pdf