Follow Slashdot stories on Twitter

 



Forgot your password?
typodupeerror
×
Math

Decades-Old Computer Science 'Boolean Sensitivity' Conjecture Solved in Two Pages (quantamagazine.org) 101

Long-time Slashdot reader Faizdog writes: The "sensitivity" conjecture stumped many top computer scientists, yet the new proof is so simple that one researcher summed it up in a single tweet.

"This conjecture has stood as one of the most frustrating and embarrassing open problems in all of combinatorics and theoretical computer science," wrote Scott Aaronson of the University of Texas, Austin, in a blog post. "The list of people who tried to solve it and failed is like a who's who of discrete math and theoretical computer science," he added in an email.

The conjecture concerns Boolean functions, rules for transforming a string of input bits (0s and 1s) into a single output bit. One such rule is to output a 1 provided any of the input bits is 1, and a 0 otherwise; another rule is to output a 0 if the string has an even number of 1s, and a 1 otherwise. Every computer circuit is some combination of Boolean functions, making them "the bricks and mortar of whatever you're doing in computer science," said Rocco Servedio of Columbia University.

"People wrote long, complicated papers trying to make the tiniest progress," said Ryan O'Donnell of Carnegie Mellon University.

Now Hao Huang, a mathematician at Emory University, has proved the sensitivity conjecture with an ingenious but elementary two-page argument about the combinatorics of points on cubes. "It is just beautiful, like a precious pearl," wrote Claire Mathieu, of the French National Center for Scientific Research, during a Skype interview. Aaronson and O'Donnell both called Huang's paper the "book" proof of the sensitivity conjecture, referring to Paul Erds' notion of a celestial book in which God writes the perfect proof of every theorem. "I find it hard to imagine that even God knows how to prove the Sensitivity Conjecture in any simpler way than this," Aaronson wrote.

This discussion has been archived. No new comments can be posted.

Decades-Old Computer Science 'Boolean Sensitivity' Conjecture Solved in Two Pages

Comments Filter:
  • by Anonymous Coward

    both get immediately stabbed, choked, stomped, and left for dead.

    Funnier when you were there.

  • Bad editing (Score:5, Insightful)

    by gweihir ( 88907 ) on Saturday July 27, 2019 @03:10PM (#58998072)

    What about actually stating somewhere in the story what the sensitivity conjecture actually is? But no, that could have been helpful...

    • Re:Bad editing (Score:5, Informative)

      by lgw ( 121541 ) on Saturday July 27, 2019 @03:56PM (#58998280) Journal

      It's apparently hidden from view behind this paywall here. [acm.org] Yay Academia, you're so useful to us.

      From wikipedia,

      The sensitivity of a Boolean function f at a given point is the number of coordinates i such that if we flip the i'th coordinate, the value of the function changes.

      So that's something. I found this attempt to define the conjecture at princeton.edu.

      What are smooth Boolean functions, and how simple are they? One measure of smoothness is the sensitivity of the function to local changes. Let the graph G(f) of a Boolean function f on the n-dimensional cube be the (bipartite) subgraph of the cube graph containing only edges with different f-values.

      The sensitivity of f, denoted s(f), is simply the maximum vertex degree of G(f). When s(f) is small compared to the number n of variables, it means that for every vertex x, flipping the bit in one coordinate will change the value of f only for very few coordinates. The basic high level question under study is what structure is implied by this smoothness?

      One measure of simplicity of a Boolean function is its Fourier degree. More precisely, let deg(f) be the degree of the unique real multilinear polynomial which equals f on every vertex of the cube. This measure of simplicity is extremely robust, in that remarkably many other parameters of Boolean functions are polynomially related to deg(f). These include the computational complexity of f in the deterministic, probabilistic, quantum and non-deterministic decision tree models.

      The sensitivity conjecture, formulated by Noam Nisan and Mario Szegedy in the 1990s, asserts that smooth functions are simple: deg(f) < (s(f))^c, for some fixed constant c independent of n and f.

      Of course, "smooth function" isn't defined, so I guess the audience was just expected to already know.

      Note on the above, the "cube" mentioned is the n-diminsional cube representing a Boolean function of n bits: every vertex of the cube is an input, and the value at each vertex is the corresponding result. The "coordinates" are thus the input bits.

      • Of course, "smooth function" isn't defined, so I guess the audience was just expected to already know.

        Just as likely, the person who copied the text from whatever source he found it simply didn’t understand what he was copying and so had no idea that concept also needed explanation.

      • Holy crap with a definition like that it's no surprise it was hard to prove. Now excuse me while I get a math degree just so I can understand the problem.

        There are some smart cookies in the world.

      • by Anonymous Coward

        My conjecture: smooth functions require smooth operators - even in Fortran. Still awaiting proof: m(j) is an example.

      • I do not get the "frustration" about a conjecture that requires so much preamble...

    • by ZipK ( 1051658 )

      What about actually stating somewhere in the story what the sensitivity conjecture actually is? But no, that could have been helpful...

      If only there was a way to find out. If... only... there... was... a... way. https://www.quantamagazine.org... [quantamagazine.org]

      • by Anonymous Coward

        Can you explain it in your own words? Just linking the article isn't helpful.

    • by slickwillie ( 34689 ) on Saturday July 27, 2019 @04:39PM (#58998470)
      Looks like someone needs a bit of sensitivity training. :whistle:
    • https://d2r55xnwy6nx47.cloudfront.net/uploads/2019/07/Boolean_Sensitivity_FINAL560-1068x1720.jpg
    • When you have a formula made up of boolean logic, things like "complexity" (not going to explain) and most other relationships between the variables are polynomial. "Sensitivity" though they didn't have a proof for that. It seemed like it should be true, but they had trouble ruling out an exponential relationship in some cases.

      What this means is that now you can do calculus with the sensitivity of a boolean function. Eg, in some cases you might be able to do a better job predicting the worst case time of an

  • by vyvepe ( 809573 ) on Saturday July 27, 2019 @04:48PM (#58998520)

    Sensitivity is one of the measures of boolean function complexity.

    Sensitivity is the maximum number of bits which need to be flipped so that the result of a boolean function flips. The maximum is taken over all the possible inputs of the boolean function.

    The sensitivity conjecture says that these alternative complexity measures are polynomially related to each other; that their result is just smaller than some constant power of the sensitivity measure.

    Hao Huang found a lower limit of sensitivity (measure) in some interesting cases which led to the proof of the conjecture.

    Not sure how useful it actually is except knowing that boolean function complexity measures are somewhat similar; i.e. none of them deviates too much from the others. Maybe somebody can point out something.

    • Re: (Score:2, Informative)

      by Anonymous Coward

      The usefulness of a proof is inversely proportional to its length, and directly proportional to its novelty. Being shorter makes it more intuitive and easier to apply to other problems; while being novel is also useful.

      The method of proof is both short and novel. That should pay dividends. The actual proposition itself is maybe not as useful.

  • by Anonymous Coward

    Like, we're smart people here. We can take a bit of maths in the summary. Yes, I know what an or gate is, I know what even parity is. Tell us the CONJECTURE that has been solved?

    • I think the conjecture is that sensitivity can be part of the framework that is used measure the complexity of a given Boolean function. I don't know the details, or even that there was a framework in the first place.

      • by Anonymous Coward

        There are a bunch of other metrics for boolean functions and they can all be converted between each other using a polynomial. Such a transformation hadn't been found for sensitivity til this paper, proving an old conjecture that such a thing exists. Everyone in the field expected such a proof to be an awful mess but instead the first proof found is a simple geometric argument about the corners of a cube.

        • but instead the first proof found is a simple geometric argument about the corners of a cube.

          Its an interesting take on visualizing boolean functions, but I think just saying "cube" is misleading. "The corners of an N-dimensional cube" would be a far more revealing wording. You can imagine the output of a function of N boolean inputs to be the labeled corners of an N-dimensional unit volume.

        • There are a bunch of other metrics for boolean functions and they can all be converted between each other using a polynomial. Such a transformation hadn't been found for sensitivity til this paper, proving an old conjecture that such a thing exists. Everyone in the field expected such a proof to be an awful mess but instead the first proof found is a simple geometric argument about the corners of a cube.

          Thank you, assuming your description is accurate. :)

    • Theoretical bullshit in other words. Now the footnotes in textbooks can be updated.

  • by Martin S. ( 98249 ) on Saturday July 27, 2019 @05:36PM (#58998704) Journal

    Does twitter count as submission to peer review or self publishing?

  • My conjecture: Twitter dumbs Computer Science down to the level of humanities.

    One such rule is to output a 1 provided any of the input bits is 1, and a 0 otherwise; another rule is to output a 0 if the string has an even number of 1s, and a 1 otherwise.

    So the first rule is trivial, it can be simplified to the output is equal to the input.

    ruleOne(Bit input) {
    Bit output = input
    send(output)
    }

    Bit state
    ruleTwo(Bit input) {
    state = state OR input
    send(state)
    }

    • Not sure what programming language that is (Java, I suppose), but if it means what I think it means, no. The bit string 10 is a sequence of input bits, but the desired output is 1, and 10 =/= 1. Even less sure what the second rule does, because I'm not sure how the variable 'state' gets initialized. But whatever it does, it's going to have to return 1 for 0, 11, 101, 1001, 1010, 1100 etc., and return 0 for 1, 10, 1011, 1101 etc., and I doubt it does that.

      At any rate, those two rules were chosen to be simple

  • This frustrating paragraph about conjecture that starts as if it will actually provide the text of it.

  • Making a discovery of this type is the dream of every scholar. Huang's proof will now almost certainly be mentioned in almost every master’s-level combinatorics course for the foreseeable future.

    What matters in this case is not just the aspect that Huang managed to prove the conjecture, but that he was able to do so elegantly in only 2 pages. The simplicity and elegance of his proof ensure that it will be discussed in almost every master’s-level combinatorics course so long as civilization lasts

Genius is ten percent inspiration and fifty percent capital gains.

Working...