In dkahle/latte: Interface to 'LattE' and '4ti2'

knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#",
  fig.path = "tools/"
)

latte

latte is an R package that makes back-end connections to LattE and 4ti2. Most of its functions were previously part of the algstat package, but have been pulled out and improved upon.

Note: the following assumes you have LattE and 4ti2 installed and latte recognizes their path. To help latte find 4ti2 and LattE on your machine, you can use set_4ti2_path() and set_latte_path() at the beginning of the session. Better, you can save environment variables that point to where their executables are using usethis::edit_r_environ(); just add two lines. For example, my lines look like: ```{bash, eval=FALSE} LATTE=/Applications/latte/bin FOURTITWO=/Applications/latte/bin

You load __latte__ like this:
```r
library("latte")

Lattice point counting

Most LattE programs are available as functions in latte. For example, latte_count() uses LattE's count to determine the number of integer points in a polytope:

latte_count(c("x + y <= 10", "x >= 0", "y >= 0"))

It's easy to confirm the solution with a simple visualization:

library(ggplot2); theme_set(theme_bw())
polytope <- data.frame(x = c(0,10,0), y = c(0,0,10))
points   <- expand.grid(x = 0:10, y = 0:10)
points   <- subset(points, x + y <= 10)
points$number <- 1:nrow(points)
ggplot(aes(x = x, y = y), data = polytope) +
  geom_polygon(fill = "red", alpha = .2) + 
  geom_text(aes(y = y + .25, label = number), size = 3.5, data = points) +
  geom_point(data = points) + 
  coord_equal()

Integer programming

In addition to table counting, it can also do integer programming with LattE's latte-maximize and latte-minimize programs. To do this, it uses tools from mpoly:

latte_max("-2 x + 3 y", c("x + y <= 10", "x >= 0", "y >= 0"))
latte_min("-2 x + 3 y", c("x + y <= 10", "x >= 0", "y >= 0"))

We can check that the solution given above is correct, but the value is not. So, it needs some more work:

points$objective <- with(points, -2*x + 3*y)
ggplot(aes(x = x, y = y), data = polytope) +
  geom_polygon(fill = "red", alpha = .2) + 
  geom_point(aes(size = objective), data = points) + 
  coord_equal()

Lattice bases

You can compute all sorts of bases of integer lattices using 4ti2. For example, if $\textbf{A}$ is the matrix

(A <- genmodel(varlvls = c(2, 2), facets = list(1, 2)))

Its Markov basis can be computed

markov(A, p = "arb")

Note that the p = "arb" signifies that arbitrary precision arithmetic is supported by using the -parb flag at the command line.

Other bases are available as well:

  zbasis(A, p = "arb")
groebner(A, p = "arb")
  graver(A)

zsolve() and qsolve()

You can solve linear systems over the integers and rationals uing zsolve() and qsolve():

mat <- rbind(
  c( 1, -1),
  c(-3,  1),
  c( 1,  1)
)
rel <- c("<", "<", ">")
rhs <- c(2, 1, 1)
sign <- c(0, 1)

zsolve(mat, rel, rhs, sign)

mat <- rbind(
  c( 1,  1),
  c( 1,  1)
)
rel <- c(">", "<")
sign <- c(0, 0)

qsolve(mat, rel, sign, p = "arb")

Primitive partition identities

The primitive partition identities can be computed with ppi():

ppi(3)

This is equivalent to the Graver basis of the numbers 1 to 3. In other words, its the numbers whose columns, when multiplied by $[1, 2, 3]$ element-wise, sum to zero:

t(1:3) %*% ppi(3)

Installation

• From CRAN

install.packages("latte")

• From Github (dev version):

if (!requireNamespace("devtools")) install.packages("devtools")
devtools::install_github("dkahle/mpoly")
devtools::install_github("dkahle/latte")

Acknowledgements

This material is based upon work supported by the National Science Foundation under Grant Nos. 1622449 and 1622369.

dkahle/latte documentation built on June 12, 2025, 12:04 p.m.