Solving k-SUM using few linear queries

Jean Cardinal, John Iacono, Aurélien Ooms

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    Abstract

    The k-SUM problem is given n input real numbers to determine whether any k of them sum to zero. The problem is of tremendous importance in the emerging field of complexity theory within P, and it is in particular open whether it admits an algorithm of complexity O(nc) with c < ⌊k/2⌋. Inspired by an algorithm due to Meiser (1993), we show that there exist linear decision trees and algebraic computation trees of depth O(n3 log2 n) solving k-SUM. Furthermore, we show that there exists a randomized algorithm that runs in Õ(n⌊k/2⌋+8) time, and performs O(n3 log2 n) linear queries on the input. Thus, we show that it is possible to have an algorithm with a runtime almost identical (up to the +8) to the best known algorithm but for the first time also with the number of queries on the input a polynomial that is independent of k. The O(n3 log2 n) bound on the number of linear queries is also a tighter bound than any known algorithm solving k-SUM, even allowing unlimited total time outside of the queries. By simultaneously achieving few queries to the input without significantly sacrificing runtime vis-à-vis known algorithms, we deepen the understanding of this canonical problem which is a cornerstone of complexity-within-P. We also consider a range of tradeoffs between the number of terms involved in the queries and the depth of the decision tree. In particular, we prove that there exist o(n)-linear decision trees of depth Õ(n3) for the k-SUM problem.

    Original languageEnglish (US)
    Title of host publication24th Annual European Symposium on Algorithms, ESA 2016
    PublisherSchloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing
    Volume57
    ISBN (Electronic)9783959770156
    DOIs
    StatePublished - Aug 1 2016
    Event24th Annual European Symposium on Algorithms, ESA 2016 - Aarhus, Denmark
    Duration: Aug 22 2016Aug 24 2016

    Other

    Other24th Annual European Symposium on Algorithms, ESA 2016
    CountryDenmark
    CityAarhus
    Period8/22/168/24/16

    Fingerprint

    Decision trees
    Trees (mathematics)
    Polynomials

    Keywords

    • H-SUM problem
    • Linear decision trees
    • Point location
    • ϵ-nets

    ASJC Scopus subject areas

    • Software

    Cite this

    Cardinal, J., Iacono, J., & Ooms, A. (2016). Solving k-SUM using few linear queries. In 24th Annual European Symposium on Algorithms, ESA 2016 (Vol. 57). [25] Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing. https://doi.org/10.4230/LIPIcs.ESA.2016.25

    Solving k-SUM using few linear queries. / Cardinal, Jean; Iacono, John; Ooms, Aurélien.

    24th Annual European Symposium on Algorithms, ESA 2016. Vol. 57 Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing, 2016. 25.

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    Cardinal, J, Iacono, J & Ooms, A 2016, Solving k-SUM using few linear queries. in 24th Annual European Symposium on Algorithms, ESA 2016. vol. 57, 25, Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing, 24th Annual European Symposium on Algorithms, ESA 2016, Aarhus, Denmark, 8/22/16. https://doi.org/10.4230/LIPIcs.ESA.2016.25
    Cardinal J, Iacono J, Ooms A. Solving k-SUM using few linear queries. In 24th Annual European Symposium on Algorithms, ESA 2016. Vol. 57. Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing. 2016. 25 https://doi.org/10.4230/LIPIcs.ESA.2016.25
    Cardinal, Jean ; Iacono, John ; Ooms, Aurélien. / Solving k-SUM using few linear queries. 24th Annual European Symposium on Algorithms, ESA 2016. Vol. 57 Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing, 2016.
    @inproceedings{c34669f383504416b184c3b2ffb932a3,
    title = "Solving k-SUM using few linear queries",
    abstract = "The k-SUM problem is given n input real numbers to determine whether any k of them sum to zero. The problem is of tremendous importance in the emerging field of complexity theory within P, and it is in particular open whether it admits an algorithm of complexity O(nc) with c < ⌊k/2⌋. Inspired by an algorithm due to Meiser (1993), we show that there exist linear decision trees and algebraic computation trees of depth O(n3 log2 n) solving k-SUM. Furthermore, we show that there exists a randomized algorithm that runs in {\~O}(n⌊k/2⌋+8) time, and performs O(n3 log2 n) linear queries on the input. Thus, we show that it is possible to have an algorithm with a runtime almost identical (up to the +8) to the best known algorithm but for the first time also with the number of queries on the input a polynomial that is independent of k. The O(n3 log2 n) bound on the number of linear queries is also a tighter bound than any known algorithm solving k-SUM, even allowing unlimited total time outside of the queries. By simultaneously achieving few queries to the input without significantly sacrificing runtime vis-{\`a}-vis known algorithms, we deepen the understanding of this canonical problem which is a cornerstone of complexity-within-P. We also consider a range of tradeoffs between the number of terms involved in the queries and the depth of the decision tree. In particular, we prove that there exist o(n)-linear decision trees of depth {\~O}(n3) for the k-SUM problem.",
    keywords = "H-SUM problem, Linear decision trees, Point location, ϵ-nets",
    author = "Jean Cardinal and John Iacono and Aur{\'e}lien Ooms",
    year = "2016",
    month = "8",
    day = "1",
    doi = "10.4230/LIPIcs.ESA.2016.25",
    language = "English (US)",
    volume = "57",
    booktitle = "24th Annual European Symposium on Algorithms, ESA 2016",
    publisher = "Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing",

    }

    TY - GEN

    T1 - Solving k-SUM using few linear queries

    AU - Cardinal, Jean

    AU - Iacono, John

    AU - Ooms, Aurélien

    PY - 2016/8/1

    Y1 - 2016/8/1

    N2 - The k-SUM problem is given n input real numbers to determine whether any k of them sum to zero. The problem is of tremendous importance in the emerging field of complexity theory within P, and it is in particular open whether it admits an algorithm of complexity O(nc) with c < ⌊k/2⌋. Inspired by an algorithm due to Meiser (1993), we show that there exist linear decision trees and algebraic computation trees of depth O(n3 log2 n) solving k-SUM. Furthermore, we show that there exists a randomized algorithm that runs in Õ(n⌊k/2⌋+8) time, and performs O(n3 log2 n) linear queries on the input. Thus, we show that it is possible to have an algorithm with a runtime almost identical (up to the +8) to the best known algorithm but for the first time also with the number of queries on the input a polynomial that is independent of k. The O(n3 log2 n) bound on the number of linear queries is also a tighter bound than any known algorithm solving k-SUM, even allowing unlimited total time outside of the queries. By simultaneously achieving few queries to the input without significantly sacrificing runtime vis-à-vis known algorithms, we deepen the understanding of this canonical problem which is a cornerstone of complexity-within-P. We also consider a range of tradeoffs between the number of terms involved in the queries and the depth of the decision tree. In particular, we prove that there exist o(n)-linear decision trees of depth Õ(n3) for the k-SUM problem.

    AB - The k-SUM problem is given n input real numbers to determine whether any k of them sum to zero. The problem is of tremendous importance in the emerging field of complexity theory within P, and it is in particular open whether it admits an algorithm of complexity O(nc) with c < ⌊k/2⌋. Inspired by an algorithm due to Meiser (1993), we show that there exist linear decision trees and algebraic computation trees of depth O(n3 log2 n) solving k-SUM. Furthermore, we show that there exists a randomized algorithm that runs in Õ(n⌊k/2⌋+8) time, and performs O(n3 log2 n) linear queries on the input. Thus, we show that it is possible to have an algorithm with a runtime almost identical (up to the +8) to the best known algorithm but for the first time also with the number of queries on the input a polynomial that is independent of k. The O(n3 log2 n) bound on the number of linear queries is also a tighter bound than any known algorithm solving k-SUM, even allowing unlimited total time outside of the queries. By simultaneously achieving few queries to the input without significantly sacrificing runtime vis-à-vis known algorithms, we deepen the understanding of this canonical problem which is a cornerstone of complexity-within-P. We also consider a range of tradeoffs between the number of terms involved in the queries and the depth of the decision tree. In particular, we prove that there exist o(n)-linear decision trees of depth Õ(n3) for the k-SUM problem.

    KW - H-SUM problem

    KW - Linear decision trees

    KW - Point location

    KW - ϵ-nets

    UR - http://www.scopus.com/inward/record.url?scp=85012977552&partnerID=8YFLogxK

    UR - http://www.scopus.com/inward/citedby.url?scp=85012977552&partnerID=8YFLogxK

    U2 - 10.4230/LIPIcs.ESA.2016.25

    DO - 10.4230/LIPIcs.ESA.2016.25

    M3 - Conference contribution

    VL - 57

    BT - 24th Annual European Symposium on Algorithms, ESA 2016

    PB - Schloss Dagstuhl- Leibniz-Zentrum fur Informatik GmbH, Dagstuhl Publishing

    ER -