David Bremner
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Research Subjects
David Bremner has a total of 59 co-authors. Here are the top co-authors by number of shared publications:
- Erik D. Demaine
Computer Science and Artificial Intelligence Laboratory, MIT, Cambridge, MA, USA
5 shared publications Antoine Deza
3 shared publications- Jeff Erickson
University of Illinois Urbana-Champaign, Urbana, IL, USA
3 shared publications - Stefan Langerman
Computer Science Department Université Libre de Bruxelles Belgium
3 shared publications - Vera Sacristán
Universitat Politecnica de Catalunya, Barcelona, Spain
3 shared publications - Achill Schürmann
Institute of Mathematics, University of Rostock, 18051 Rostock, Germany
2 shared publications
Latest Publications
- 2 July 2026
- Published by Springer Nature
- p. 199-214
OOPredictor: Predicting Object-Oriented Accesses Using Static Analysis
- 2 July 2026
- Published by Springer Nature
- p. 199-214
OOPredictor: Predicting Object-Oriented Accesses Using Static Analysis
- 18 February 2026
- Published by Springer Nature
- p. 175-207
Outer Approximations of Core Points for Integer Programming
- 18 February 2026
- Published by Springer Nature
- p. 175-207
Outer Approximations of Core Points for Integer Programming
- Open Access
Efficient Compilation of Algorithms into Compact Linear Programs
Linear Programming (LP) is widely applied in industry and is a key component of various other mathematical problem-solving techniques. Recent work introduced an LP compiler translating polynomial-time, polynomial-space algorithms into polynomial-size LPs using intuitive high-level programming languages, offering a promising alternative to manually specifying each set of constraints through Algebraic Modeling Languages (AMLs). However, the resulting LPs, while polynomial in size, are often extremely large, posing challenges for existing LP solvers. In this paper, we propose a novel approach for generating substantially smaller LPs from algorithms. Our goal is to establish minimum-size compact LP formulations for problems in P having natural formulations with exponential extension complexities. Our broader vision is to enable the systematic generation of Compact Integer Programming (CIP) formulations for problems with exponential-size IPs having polynomial-time separation oracles. To this end, we introduce a hierarchical linear pipelining technique that decomposes nested program structures into synchronized regions with well-defined execution transitions -- functions of compile-time parameters. This decomposition allows us to localize LP constraints and variables within each region, significantly reducing LP size without the loss of generality, ensuring the resulting LP remains valid for all inputs of size $n$. We demonstrate the effectiveness of our method on two benchmark problems -- the makespan problem, which has exponential extension complexity, and the weighted minimum spanning tree problem -- both of which have exponential-size natural LPs. Our results show up to a $25$-fold reduction in LP size and substantial improvements in solver performance across both commercial and non-commercial LP solvers.Open AccessEfficient Compilation of Algorithms into Compact Linear Programs
Linear Programming (LP) is widely applied in industry and is a key component of various other mathematical problem-solving techniques. Recent work introduced an LP compiler translating polynomial-time, polynomial-space algorithms into polynomial-size LPs using intuitive high-level programming languages, offering a promising alternative to manually specifying each set of constraints through Algebraic Modeling Languages (AMLs). However, the resulting LPs, while polynomial in size, are often extremely large, posing challenges for existing LP solvers. In this paper, we propose a novel approach for generating substantially smaller LPs from algorithms. Our goal is to establish minimum-size compact LP formulations for problems in P having natural formulations with exponential extension complexities. Our broader vision is to enable the systematic generation of Compact Integer Programming (CIP) formulations for problems with exponential-size IPs having polynomial-time separation oracles. To this end, we introduce a hierarchical linear pipelining technique that decomposes nested program structures into synchronized regions with well-defined execution transitions -- functions of compile-time parameters. This decomposition allows us to localize LP constraints and variables within each region, significantly reducing LP size without the loss of generality, ensuring the resulting LP remains valid for all inputs of size $n$. We demonstrate the effectiveness of our method on two benchmark problems -- the makespan problem, which has exponential extension complexity, and the weighted minimum spanning tree problem -- both of which have exponential-size natural LPs. Our results show up to a $25$-fold reduction in LP size and substantial improvements in solver performance across both commercial and non-commercial LP solvers. - Open Access
Outer approximations of core points for integer programming
For several decades the dominant techniques for integer linear programming have been branching and cutting planes. Recently, several authors have developed core point methods for solving symmetric integer linear programs (ILPs). An integer point is called a core point if its orbit polytope is lattice-free. It has been shown that for symmetric ILPs, optimizing over the set of core points gives the same answer as considering the entire space. Existing core point techniques rely on the number of core points (or equivalence classes) being finite, which requires special symmetry groups. In this paper we develop some new methods for solving symmetric ILPs (based on outer approximations of core points) that do not depend on finiteness but are more efficient if the group has large disjoint cycles in its set of generators.
Open AccessOuter approximations of core points for integer programming
For several decades the dominant techniques for integer linear programming have been branching and cutting planes. Recently, several authors have developed core point methods for solving symmetric integer linear programs (ILPs). An integer point is called a core point if its orbit polytope is lattice-free. It has been shown that for symmetric ILPs, optimizing over the set of core points gives the same answer as considering the entire space. Existing core point techniques rely on the number of core points (or equivalence classes) being finite, which requires special symmetry groups. In this paper we develop some new methods for solving symmetric ILPs (based on outer approximations of core points) that do not depend on finiteness but are more efficient if the group has large disjoint cycles in its set of generators.
- 6 January 2021
- Published by Taylor & Francis in Optimization Methods and Software
- Vol. 37 (3) , 954-981
Sparktope: linear programs from algorithms
In a recent paper, Avis, Bremner, Tiwary and Watanabe gave a method for constructing linear programs (LPs) based on algorithms written in a simple programming language called Sparks. If an algorithm produces the solution x to a problem in polynomial time and space then the LP constructed is also of polynomial size and its optimum solution contains x as well as a complete execution trace of the algorithm. Their method led us to the construction of a compiler called sparktope which we describe in this paper. This compiler allows one to generate polynomial sized LPs for problems in that have exponential extension complexity, such as matching problems in non-bipartite graphs. In this paper, we describe sparktope, the language Sparks, and the assembler instructions and LP constraints it produces. This is followed by two concrete examples, the makespan problem and the problem of testing if a matching in a graph is maximum, both of which are known to have exponential extension complexity. Computational results are given. In discussing these examples, we make use of visualization techniques included in sparktope that may be of independent interest. The extremely large linear programs produced by the compiler appear to be quite challenging to solve using currently available software. Since the optimum LP solutions can be computed independently they may be useful as benchmarks. Further enhancements of the compiler and its application are also discussed.- 6 January 2021
- Published by Taylor & Francis in Optimization Methods and Software
- Vol. 37 (3) , 954-981
Sparktope: linear programs from algorithms
In a recent paper, Avis, Bremner, Tiwary and Watanabe gave a method for constructing linear programs (LPs) based on algorithms written in a simple programming language called Sparks. If an algorithm produces the solution x to a problem in polynomial time and space then the LP constructed is also of polynomial size and its optimum solution contains x as well as a complete execution trace of the algorithm. Their method led us to the construction of a compiler called sparktope which we describe in this paper. This compiler allows one to generate polynomial sized LPs for problems in that have exponential extension complexity, such as matching problems in non-bipartite graphs. In this paper, we describe sparktope, the language Sparks, and the assembler instructions and LP constraints it produces. This is followed by two concrete examples, the makespan problem and the problem of testing if a matching in a graph is maximum, both of which are known to have exponential extension complexity. Computational results are given. In discussing these examples, we make use of visualization techniques included in sparktope that may be of independent interest. The extremely large linear programs produced by the compiler appear to be quite challenging to solve using currently available software. Since the optimum LP solutions can be computed independently they may be useful as benchmarks. Further enhancements of the compiler and its application are also discussed.- Open Access
Sparktope: linear programs from algorithms
In a recent paper Avis, Bremner, Tiwary and Watanabe gave a method for constructing linear programs (LPs) based on algorithms written in a simple programming language called Sparks. If an algorithm produces the solution $x$ to a problem in polynomial time and space then the LP constructed is also of polynomial size and its optimum solution contains $x$ as well as a complete execution trace of the algorithm. Their method led us to the construction of a compiler called Sparktope which we describe in this paper. This compiler allows one to generate polynomial sized LPs for problems in P that have exponential extension complexity, such as matching problems in non-bipartite graphs. In this paper we describe Sparktope, the language Sparks, and the assembler instructions and LP constraints it produces. This is followed by two concrete examples, the makespan problem and the problem of testing if a matching in a graph is maximum, both of which are known to have exponential extension complexity. Computational results are given. In discussing these examples we make use of visualization techniques included in Sparktope that may be of independent interest. The extremely large linear programs produced by the compiler appear to be quite challenging to solve using currently available software. Since the optimum LP solutions can be computed independently they may be useful as benchmarks. Further enhancements of the compiler and its application are also discussed.Open AccessSparktope: linear programs from algorithms
In a recent paper Avis, Bremner, Tiwary and Watanabe gave a method for constructing linear programs (LPs) based on algorithms written in a simple programming language called Sparks. If an algorithm produces the solution $x$ to a problem in polynomial time and space then the LP constructed is also of polynomial size and its optimum solution contains $x$ as well as a complete execution trace of the algorithm. Their method led us to the construction of a compiler called Sparktope which we describe in this paper. This compiler allows one to generate polynomial sized LPs for problems in P that have exponential extension complexity, such as matching problems in non-bipartite graphs. In this paper we describe Sparktope, the language Sparks, and the assembler instructions and LP constraints it produces. This is followed by two concrete examples, the makespan problem and the problem of testing if a matching in a graph is maximum, both of which are known to have exponential extension complexity. Computational results are given. In discussing these examples we make use of visualization techniques included in Sparktope that may be of independent interest. The extremely large linear programs produced by the compiler appear to be quite challenging to solve using currently available software. Since the optimum LP solutions can be computed independently they may be useful as benchmarks. Further enhancements of the compiler and its application are also discussed. - 30 August 2019
- Published by Springer Nature in Peer-to-Peer Networking and Applications
- Vol. 13 (1) , 412-423
Achieve privacy-preserving simplicial depth query over collaborative cloud servers
- 30 August 2019
- Published by Springer Nature in Peer-to-Peer Networking and Applications
- Vol. 13 (1) , 412-423
Achieve privacy-preserving simplicial depth query over collaborative cloud servers
- 1 July 2019
- Published by Elsevier in Discrete Applied Mathematics
- Vol. 265, 22-39
Polynomial size linear programs for problems in P
- 1 July 2019
- Published by Elsevier in Discrete Applied Mathematics
- Vol. 265, 22-39
Polynomial size linear programs for problems in P
- Open Access
Polynomial size linear programs for problems in P
A perfect matching in an undirected graph $G=(V,E)$ is a set of vertex disjoint edges from $E$ that include all vertices in $V$. The perfect matching problem is to decide if $G$ has such a matching. Recently Rothvo{\ss} proved the striking result that the Edmonds' matching polytope has exponential extension complexity. Here for each $n=|V|$ we describe a perfect matching polytope that is different from Edmonds' polytope and define a weaker notion of extended formulation. We show that the new polytope has a weak extended formulation (WEF) $Q$ of polynomial size. For each graph $G$ with $n$ vertices we can readily construct an objective function so that solving the resulting linear program over $Q$ decides whether or not $G$ has a perfect matching. The construction is uniform in the sense that, for each $n$, a single polytope is defined for the class of all graphs with $n$ nodes. The method extends to solve poly time optimization problems, such as the weighted matching problem. In this case a logarithmic (in the weight of the optimum solution) number of optimizations are made over the constructed WEF. The method described in the paper involves construction of a compiler that converts an algorithm given in a prescribed pseudocode into a polytope. It can therefore be used to construct a polytope for any decision problem in {\bf P} which can be solved by a given algorithm. Compared with earlier results of Dobkin-Lipton-Reiss and Valiant our method allows the construction of explicit linear programs directly from algorithms written for a standard register model, without intermediate transformations. We apply our results to obtain polynomial upper bounds on the non-negative rank of certain slack matrices related to membership testing of languages in {\bf P/Poly}.Open AccessPolynomial size linear programs for problems in P
A perfect matching in an undirected graph $G=(V,E)$ is a set of vertex disjoint edges from $E$ that include all vertices in $V$. The perfect matching problem is to decide if $G$ has such a matching. Recently Rothvo{\ss} proved the striking result that the Edmonds' matching polytope has exponential extension complexity. Here for each $n=|V|$ we describe a perfect matching polytope that is different from Edmonds' polytope and define a weaker notion of extended formulation. We show that the new polytope has a weak extended formulation (WEF) $Q$ of polynomial size. For each graph $G$ with $n$ vertices we can readily construct an objective function so that solving the resulting linear program over $Q$ decides whether or not $G$ has a perfect matching. The construction is uniform in the sense that, for each $n$, a single polytope is defined for the class of all graphs with $n$ nodes. The method extends to solve poly time optimization problems, such as the weighted matching problem. In this case a logarithmic (in the weight of the optimum solution) number of optimizations are made over the constructed WEF. The method described in the paper involves construction of a compiler that converts an algorithm given in a prescribed pseudocode into a polytope. It can therefore be used to construct a polytope for any decision problem in {\bf P} which can be solved by a given algorithm. Compared with earlier results of Dobkin-Lipton-Reiss and Valiant our method allows the construction of explicit linear programs directly from algorithms written for a standard register model, without intermediate transformations. We apply our results to obtain polynomial upper bounds on the non-negative rank of certain slack matrices related to membership testing of languages in {\bf P/Poly}. - Open Access
Computing the Planar $β$-skeleton Depth
For $\beta \geq 1$, the \emph{$\beta$-skeleton depth} ($\SkD_\beta$) of a query point $q\in \mathbb{R}^d$ with respect to a distribution function $F$ on $\mathbb{R}^d$ is defined as the probability that $q$ is contained within the \emph{$\beta$-skeleton influence region} of a random pair of points from $F$. The $\beta$-skeleton depth of $q\in \mathbb{R}^d$ can also be defined with respect to a given data set $S\subseteq \mathbb{R}^d$. In this case, computing the $\beta$-skeleton depth is based on counting all of the $\beta$-skeleton influence regions, obtained from pairs of points in $S$, that contain $q$. The $\beta$-skeleton depth introduces a family of depth functions that contains \emph{spherical depth} and \emph{lens depth} for $\beta=1$ and $\beta=2$, respectively. The straightforward algorithm for computing the $\beta$-skeleton depth in dimension $d$ takes $O(dn^2)$. This complexity of computation is a significant advantage of using the $\beta$-skeleton depth in multivariate data analysis because unlike most other data depths, the time complexity of the $\beta$-skeleton depth grows linearly rather than exponentially in the dimension $d$. The main results of this paper include two algorithms. The first one is an optimal algorithm that takes $\Theta(n\log n)$ for computing the planar spherical depth, and the second algorithm with the time complexity of $O(n^{\frac{3}{2}+\epsilon})$ is for computing the planar $\beta$-skeleton depth, $\beta >1$. By reducing the problem of \textit{Element Uniqueness}, we prove that computing the $\beta$-skeleton depth requires $\Omega(n \log n)$ time. Some geometric properties of $\beta$-skeleton depth are also investigated in this paper. These properties indicate that \emph{simplicial depth} ($\SD$) is linearly bounded by $\beta$-skeleton depth. Some experimental bounds for different depth functions are also obtained in this paper.Open AccessComputing the Planar $β$-skeleton Depth
For $\beta \geq 1$, the \emph{$\beta$-skeleton depth} ($\SkD_\beta$) of a query point $q\in \mathbb{R}^d$ with respect to a distribution function $F$ on $\mathbb{R}^d$ is defined as the probability that $q$ is contained within the \emph{$\beta$-skeleton influence region} of a random pair of points from $F$. The $\beta$-skeleton depth of $q\in \mathbb{R}^d$ can also be defined with respect to a given data set $S\subseteq \mathbb{R}^d$. In this case, computing the $\beta$-skeleton depth is based on counting all of the $\beta$-skeleton influence regions, obtained from pairs of points in $S$, that contain $q$. The $\beta$-skeleton depth introduces a family of depth functions that contains \emph{spherical depth} and \emph{lens depth} for $\beta=1$ and $\beta=2$, respectively. The straightforward algorithm for computing the $\beta$-skeleton depth in dimension $d$ takes $O(dn^2)$. This complexity of computation is a significant advantage of using the $\beta$-skeleton depth in multivariate data analysis because unlike most other data depths, the time complexity of the $\beta$-skeleton depth grows linearly rather than exponentially in the dimension $d$. The main results of this paper include two algorithms. The first one is an optimal algorithm that takes $\Theta(n\log n)$ for computing the planar spherical depth, and the second algorithm with the time complexity of $O(n^{\frac{3}{2}+\epsilon})$ is for computing the planar $\beta$-skeleton depth, $\beta >1$. By reducing the problem of \textit{Element Uniqueness}, we prove that computing the $\beta$-skeleton depth requires $\Omega(n \log n)$ time. Some geometric properties of $\beta$-skeleton depth are also investigated in this paper. These properties indicate that \emph{simplicial depth} ($\SD$) is linearly bounded by $\beta$-skeleton depth. Some experimental bounds for different depth functions are also obtained in this paper.