I spent some time exploring the parameter space for the example given in 2026-07-09. More specifically, I modified the weights of triangles as follows:

I then did an exhaustive computation of with a step size of . For each set of weights, I solved the flat norm LP and stored the objective value , and whether is integral. In other words, I looked at the following map:

I then plotted this map using a contour plot:

center

We find the following interesting facts:

  • Every fractional solution has a corresponding integral solution with the same objective .
  • For each objective value , its corresponding parameter space is divided into two parts: fractional vertices and integral vertices.

My idea is as follows:

  1. Compute the flat norm LP
  2. If the solution is fractional, tweak the weights so that we get an equivalent integral solution.

This strategy requires us to have a strong understanding of the parameter space. That is, fix and and look at the space . Assume that the LP gave as in our example. For any vertex of the LP , consider . Then our objective is given by

We want to look at the following hypersurface in where :

Notice that the map is smooth and on . One approach to this is as follows:

  1. Set by the given parameters.
  2. Solve the flat norm LP to find , record the objective value .
  3. At step , do the following:
    1. If , stop.
    2. Otherwise, set
    3. Find such that .

The difficult step is projecting back into . Let . Notice that

implies that

So, we get back to by setting

However, this doesn’t respect the homology constraints. Notice that

Adding a vector to might work. Notice that

I’m not sure what to set to. We need

What we need to do, is solve the following LP:

Call this problem and the flat norm . Then our algorithm is as follows:

  1. Set by the given parameters.
  2. Solve to find , record the objective value .
  3. At step , do the following:
    1. If , stop.
    2. Otherwise, set
    3. Find by solving .

However, I don’t know if this will converge and if it does, converge in a linear number of steps. Maybe there is a fast way to solve ?