Introduction and motivation

This blog post is an effort led by Joseph Salmon, with contributions from Tiffany Ding and Jean-Baptiste Fermanian, to synthesize joint research by the three authors. The full paper (Ding, Fermanian, and Salmon 2026) is available on arXiv and the code is on Github.

Motivating example: Pl@ntNet

Pl@ntNet, a leading citizen-science platform for plant identification, serves as our real-world context for exploring these ideas. More precisely we focus on the Pl@ntNet-300K dataset (Garcin et al. 2021), a representative and more manageable subset of the full Pl@ntNet collection. The Pl@ntNet-300K dataset is available on Zenodo, with documentation and code provided on the Pl@ntNet-300K GitHub repository. The dataset comprises approximately 300,000 images spanning over 1,000 plant species. Here are a few sample images from the Pl@ntNet-300K dataset (cropped to a consistent size for visualization):

The dataset exhibits a highly imbalanced class distribution: a few species are well-represented with numerous images, while the majority have only a few examples. This characteristic makes it an ideal benchmark for studying long-tailed classification problems, as illustrated in the interactive figure below.

Plant species visualization

The interactive visualization below lets you explore the species distribution in the Pl@ntNet-300K training set, enriched with their IUCN conservation statuses.

Y-Scale: Log Linear

Species Preview

This visualization provides a dynamic way to explore the intersection of species popularity and ecological importance. “At-risk” species are highlighted and typically have far fewer observations, reflecting the challenges in documenting rare or threatened flora. Use the interactive features (hover the points on the left!) to navigate observation counts, conservation status, and the distribution of both common and rare species.

Notation and model

Let be a (feature, label) pair. In our example, is an image, and is the true label (species) associated with it. Let be an estimate of the probability that the label is given features . Let be a user-specified miscoverage probability, so corresponds to the desired coverage level.

The available data is randomly split into four distinct sets: a training set for fitting the model , a validation set for hyperparameter tuning (in our experiments, the only hyperparameter is the number of training epochs), a calibration set for to evaluate coverage, and a test set for final evaluation. Note that in order for the coverage guarantees from conformal prediction to hold, the calibration set must be exchangeable with the test set. The random splitting procedure ensure this is satisfied.

Marginal coverage

In classification setting, suppose our aim is to control the size (here the cardinality) of our prediction sets while ensuring marginal coverage. This corresponds to the following optimization problem:

The following result due to Sadinle, Lei, and Wasserman (2019) describes the optimal set.

Interpretation: This result implies that the smallest sets that achieve marginal coverage are created by including the classes with the highest probability of being the correct class. Specifically, we include all labels where exceeds some threshold chosen to ensure the desired coverage level of .

In practice: While we do not have direct access to , we can use an estimate to approximate the optimal prediction set for a chosen threshold :

To ensure marginal coverage of , we select by rewriting in terms of a conformal score: where the score is defined as

By setting as the -level quantile of the calibration scores for , i.e., -th largest value in , the conformal prediction set achieves a marginal coverage guarantee (Vovk, Gammerman, and Shafer 2005), that is,

We will refer to the above procedure as Standard Conformal Prediction (Standard CP) with the softmax score function (so named because the that appears in is frequently obtained from a softmax vector). Note that other scores have also been considered in the literature, see for instance Romano, Sesia, and Candès (2020).

We generalize this procedure for generating prediction sets in Algorithm 1. Standard CP is a special case where the threshold function applies the same threshold to all classes. However, the other conformal procedures we present below, such as Classwise CP, impose different thresholds for each class.

Currently (as of October 2025), Standard CP with softmax is more or less the strategy used to generate prediction sets in the Pl@ntNet app. This performs reasonably well, but can we do better?

2D example

To build intuition, let’s visualize the Standard CP prediction sets for a simple 2D Gaussian mixture model.

Parameters

We generate samples from a mixture of Gaussian distributions with the following parameters:

Parameters

Visualizing the data

The data-generating model is a three-class Gaussian mixture with known parameters (means, covariances, mixing proportions) given above, enabling exact density and theoretical boundary computation. We provide an interactive visualization below.

In both plots, the red boundary is the decision boundary of the Bayes classifier (the theoretically optimal boundary).

• Left plot: Individual class densities (color-filled contours) and mixture density (grey level lines).
• Right plot: The points are samples from the mixture distribution, colored by true class. The colored shading indicates the Bayes classifier’s predicted class for each region.

Visualizing Standard CP sets

Concerning the distribution , we provide three candidates in our Gaussian mixture model visualization, though for the moment only the first (true density function) is used:

• Theoretical: (only available in simulations),
• Empirical: is a Gaussian mixture whose parameters are estimated with vanilla estimators (empirical means, empirical covariances and empirical proportions),
• Logistic Reg.: is obtained by logistic regression.

We now provide a visualization for the Standard conformal prediction, as decribed in the previous section. Hence, our classifier can output multiple classes, forming prediction sets rather than a single label. The size of these sets is controlled by the allowed miscoverage level (accessible through the slider), which reflects the confidence of the predictions.

As varies, the prediction sets shrink:small yields larger, conservative sets, while large allows smaller, selective ones. This reflects the core principle of conformal prediction, balancing coverage and uncertainty.

0.15

Using the slider above reveals two extremes of this trade-off:

• When is small (high coverage), the classifier may need to include all classes in some regions to meet the coverage requirement. For example, at , the central area contains full prediction sets.
• When is large (low coverage), it may output empty sets in uncertain regions (shown in white), as seen around . If a non-empty output is required, one can instead return the class with the highest conditional probability.

Together, these extremes illustrate how directly controls the size–coverage trade-off in conformal prediction.

Conditional coverage

A concern with the standard conformal prediction approach is that all classes are treated similarly. If certain rare classes behave differently from the majority, they may never appear in the prediction set. For instance, the classifier may consistently assign low probabilities to rare classes, as these are not sufficiently represented during training and then, they never get above the threshold.

For this reason, it makes sense to control the conditional coverage for all classes , while targeting sets of minimum size. Then the optimization formulation now becomes:

Sadinle, Lei, and Wasserman (2019) have shown that the optimal solution for such a set:

Interpretation: the optimal way to get conditional coverage is to select the labels whose probability is larger than a particular threshold , where now the threshold can be adapted in a class-wise fashion, and is fixed as the -quantile of the conditional distribution knowing , i.e, .

In practice, the threshold of each class is now computed as the quantile of the scores on class . This is known under the name Mondrian conformal prediction (Vovk, Gammerman, and Shafer 2005). Formally, for any class , we set as the score of the calibration points over class , where is the number of these points. It corresponds to applying Algorithm 1 with the threshold function equal to the vector of these conditional quantiles. We refer to this method as Conditional conformal prediction.

For classes whose number of calibration points is not large enough (i.e., ), this threshold is fixed as the maximum possible value of the score function, or formally to . It implies that these rare classes will always be included in the prediction sets. It can be observed below in the plots for small enough.

0.15

The figure above illustrates the influence of conditional modeling: overall, the predicted sets tend to be larger, especially when the miscoverage rate is close to 0, and often include the marginal prediction sets. In practice, estimating the conditional distribution in high-dimensional spaces with limited data is challenging, which can lead to excessively large prediction sets. We also include bar plots showing per-class coverage, which reveal that Standard CP tends to under-cover rare classes (e.g., Class 2 in green). This poor class-conditional behavior motivates our next proposal.

Macro-coverage

Standard conformal prediction often under-covers rare classes, despite producing compact prediction sets. On the other end of the spectrum, conditional conformal prediction ensures equal coverage across all classes, but at the cost of unwieldy, oversized sets. What if we could find a middle ground?

This is what we tackle by introducing a macro-coverage constraint, inspired by the macro-accuracy metric in multi-class classification. Our objective is to minimize the expected size of prediction sets while ensuring that all classes (including those with limited data) benefit from equitable and reliable coverage.

The macro-coverage formulation reads as follows: where we defined the macro-coverage as The motivation of this program is to treat all classes equally. We provide an adaptation of the previous proposition for this new constraints:

Though we do not have access to and in practice, we have estimates and from our classifier and the distribution of empirical training labels, respectively. By creating prediction sets as for a threshold . We choose to achieve marginal coverage in the following way: Observe that can be rewritten as , where and stands for prevalence-adjusted softmax.

In summary, the method we propose is simply running Algorithm 1 with the score function (which we will refer to as Standard with ) and as the vector of quantile of the scores, where is the -th largest value in . This corresponds to running Standard CP with the new score. Note that for fair comparisons with Standard CP, we set the threshold in Standard with PAS to achieve marginal coverage , i.e., we fix so .

Then, this achieves the desired marginal coverage guarantee while (approximately) optimally trading off set size and macro-coverage. In the visualization below, we also illustrate the variation of the (empirical) coverage per class w.r.t. (evaluated on the test set).

: 0.15

Weighted-macro coverage

Recall that macro-coverage is the unweighted average of the class-conditional coverages. However, in some settings it may be more important to cover some classes than others; in these settings, it makes sense to instead optimize a weighted average of the class-conditional coverages. Given user-chosen class weights for that sum to one, we can define the -weighted macro-coverage as

We can approximate these optimal sets by running standard CP with the weighted prevalence-adjusted softmax (WPAS), as the score function.

Again, for fair comparisons with Standard CP, we set the threshold in Standard with WPAS to achieve marginal coverage , i.e., we fix so .

Summary of Propositions 1-4

It might help readers to compare at a glance the objective and the quantity being thresholded in each approach (for instance vs ). Below is a compact synthesis of the propositions discussed above.

Theoretical synthesis (coverage )

Constraint	Quantity thresholded
Marginal coverage	(same for all y)
Class-conditional coverage	(class-specific)
Macro-coverage	(prevalence-adjusted)
Weighted macro coverage	(weights )

In each case, is the threshold that ensures marginal coverage (or in the case of class-conditional coverage, is chosen to ensure class-conditional coverage for class , which implies marginal coverage after marginalizing over classes).

Conformal prediction in action on Pl@ntNet-300K

We will now turn back on the Pl@ntNet-300K dataset presented earlier.

Evaluation metrics

We introduce here some evaluation metrics of interest. Let denote the empirical coverage for class (evaluated on the test set), and let be the target coverage level. We leverage in particular the per-class coverage , through class-balanced averages: the at‑risk class-coverage average and the not‑at‑risk average computed analogously.

Evaluation metrics ( : empirical coverage for class )

Metric	Definition	Target
Avg. set size		Lower
MarginalCov		Higher
MacroCov		Higher
FracBelow50%		Lower
UnderCovGap		Lower
At-risk average		Higher
Not-at-risk average		Higher

Conclusion

In summary, conformal prediction provides a principled and flexible framework for uncertainty quantification in plant species identification, especially in the presence of long-tailed and imbalanced data. By carefully choosing the coverage notion, we can achieve both reliable guarantees and practical interpretability, empowering both researchers and practitioners to make more informed decisions in challenging real-world settings. For the interested reader the associated paper not only consider new conformal score function approaches, we also propose another approach that requires modifying the conformal procedure itself.

References

Gaussian elimination

Here is a simple visualisation of the Gaussian elimination steps:

and a more complete one:

For more details, the Python source code is available here: https://github.com/josephsalmon/Tweets/tree/master/Pivot_Gauss_video

Introduction & formulation

Isotonic regression is a technique used to fit a non-decreasing function to a set of data points. We can think of isotonic regression as a generalization of linear regression where the function is constrained to be non-decreasing.

More formally suppose that one collects sample points and has weights associated with each data point.

Note: when no a priori weights are given, we can set for all .

Then, the isotonic regression problem can be formulated as follows:

Optimization, duality, etc.

The formulation of the isotonic regression problem given in Equation 1 is a quadratic program (QP) with linear constraints. Using a matrix notation, introducing the matrix the isotonic regression problem can be formulated as follows:

In what follows we will write , assuming that for all , so . Hence, we can rewrite the isotonic regression problem as

Hence, the isotonic regression problem can be formulated as a convex quadratic program with linear constraints.

Algorithm

The intuition behind the PAVA algorithm is to merge adjacent blocks of constant values in the primal vector, as the targeted solution is simply the average of the observe signal over each block. Hence, the algorithm aims at creating the blocks of constant values in the primal vector. The dual variables can be inferred from the solution from the previous lemma.

import numpy as np

def PAVA(y, w):
    n = len(y)
    r = y.copy()
    ws = w.copy()
    target = [[i] for i in range(n)]
    i = 1
    counter = 0
    while i < n:
        if r[i] < r[i - 1]:  # Find adjacent violators
            # Pool the violators
            r[i] = (ws[i] * r[i] + ws[i - 1] * r[i - 1]) / (ws[i] + ws[i - 1])
            ws[i] += ws[i - 1]
            target[i] = target[i-1] + target[i]
            r.pop(i - 1)
            ws.pop(i - 1)
            target.pop(i - 1)
            n -= 1
            # Move back one step if possible
            if i > 1:
                i -= 1
        else:
            i += 1
            counter += 1

    sol = np.zeros_like(y)
    for i, block in enumerate(target):
        sol[block] = r[i]
    return sol, ws, target

def isotonic_regression(z, w):
    y = z.copy()
    n=len(y)
    i = 0
    target = np.arange(len(y))
    targets = [target.copy()]
    idx = [0]
    while i < n:
        k = target[i] + 1
        if k == n:
            break
        if y[i] < y[k]:
            # We are in an increasing subsequence.
            i = k
            targets.append(target.copy())
            idx.append(k)
            continue
        sum_wy = w[i] * y[i]
        sum_w = w[i]
        while True:
            # We are within a decreasing subsequence.
            prev_y = y[k]
            sum_wy += w[k] * y[k]
            sum_w += w[k]
            k = target[k] + 1
            if k == n or prev_y < y[k]:
                targets.append(target.copy())
                idx.append(k)

                # Non-singleton decreasing subsequence is finished,
                # update first entry.
                y[i] = sum_wy / sum_w
                w[i] = sum_w

                target[i] = k - 1
                target[k - 1] = i

                if i > 0:
                    # Backtrack if we can.  This makes the algorithm
                    # single-pass and ensures O(n) complexity.
                    i = target[i - 1]
                # Otherwise, restart from the same point.
                break

    # Reconstruct the solution.
    i = 0
    while i < n:
        k = target[i] + 1
        y[i + 1 : k] = y[i]
        i = k
    return y, targets, idx

def replace_after_first_non_increasing(x, w=w):
    n = len(x)
    for i in range(1, n):
        if x[i] < x[i - 1]:
            mean_value = np.sum(x[i:] * w[i:]) / np.sum(w[i:])
            x[i:] = mean_value
            break
    return x

Acknowledgement

I am grateful to Hugo Negrel for his kind help, catching a few typos in the first version of the post.

References

Bellec, P. C., J. Salmon, and S. Vaiter. 2017. “A Sharp Oracle Inequality for Graph-Slope.” Electron. J. Statist. 11 (2): 4851–70. https://arxiv.org/pdf/1706.06977.pdf.

Best, M. J., and N. Chakravarti. 1990. “Active Set Algorithms for Isotonic Regression; a Unifying Framework.” Math. Programming 47 (3): 425–39.

Bogdan, M., E. van den Berg, C. Sabatti, W. Su, and E. J. Candès. 2015. “SLOPE-adaptive Variable Selection via Convex Optimization.” Ann. Appl. Stat. 9 (3): 1103.

Boyd, S., and L. Vandenberghe. 2004. Convex Optimization. Cambridge University Press.

Pedregosa, F. 2013. “Isotonic Regression.” https://fa.bianp.net/blog/2013/isotonic-regression/.

Robertson, Tim, F. T. Wright, and R. L. Dykstra. 1988. “Order Restricted Statistical Inference,” Wiley series in probability and mathematical statistics: Probability and mathematical statistics, xx+521.

Zeng, X., and M. A. T. Figueiredo. 2014. “The Ordered Weighted Norm: Atomic Formulation, Projections, and Algorithms.” ArXiv e-Prints.

History of

First a bit of history on (pronounced “Lay-tech” or “Lah-tech”). is a typesetting system that was created by Leslie Lamport in 1984. It is based on Donald Knuth’s typesetting system. LaTeX is widely used in academia for the communication and publication of scientific documents in many fields, including mathematics, computer science, engineering, physics, chemistry, biology, and economics. LaTeX is also used in the humanities and social sciences. LaTeX is free and open-source software. It was the prototype of the modern scientific writing, and it is still the standard in many fields, especially in mathematics and computer science as it’s a good way to write equations, and to go towards literate programming.

As a short motivation, I will show you two books from the same author, one written before using and one after. Compare the two following images (you can click on them to enlarge):

Conclusion: two books, same author, but very different scientific rendering.

Pros for

Below I list some of the important points that make LaTeX the standard tool for scientific writing.

Cons for

As you have understood, is a great tool for scientific writing, but it is not perfect. Here are some of the cons of using :

Tables and figures are not easy to handle

For tables, consider Tables generator, as modifying a table could lead to horrible results. For instance, the following code will include a table in your document:

\begin{tabular}{lllll}
    Col1  & Col2  &  ...   & Col4 & Col5   \\
    oih   & oih   & oih    &      & oih    \\
    oh    & oih   & oi     & o    & o
\end{tabular}

as follows:

Col1	Col2	…	Col4	Col5
oih	oih	oih		oih
oh	oih	oi	o	o
ooh	oh	oh	oho	oho

Note that in Markdown (the language used to write this document), you can use the following code to include a table:

| Col1  | Col2  |  ...   | Col4 | Col5    |
|-----|-----|-----|-----|-----|
| oih | oih | oih |     | oih |
| oh  | oih | oi  | o   | o   |
| ooh | oh  | oh  | oho | oho |

For images, that’s a long story. See for instance this post. Some authors recommend using tikz for simple figures, and pgfplots for plots:I don’t. You could instead use Inkscape to draw your figures, and then export as pdf files, and include the outputs in your document. That’s what I do, and I am happy with the result. This is WYSIWYG (when you draw), and you can easily modify your figure afterwards, and version it ( svg is fine for versioning, while pdf is not). Alternative tools could be using R or Python to generate your plots, and then include them in your document.

What’s next?

In the last few years, some alternatives to have emerged, like Markdown, Quarto, or RMarkdown. These tools are simpler to use than , and they are more WYSIWYG. using I would recommend using Markdown, RMarkdown or Quarto for writing blog posts, reports, presentations or light documents with scientific content.

Moreover, a recent alternative to is Typst, which is a new typesetting system that is designed to be more user-friendly and easier to use than . Typst is still in development, but it shows promise as a modern alternative to .

Additional resources

• Getting Started with LaTeX by M. Frenkel.
• Templates, tips and tools by J. Salmon.

References

Definition and notation

First, let us define the probability simplex in , and the uniform distribution in , and the standard basis vectors , where .

Formally, the standard soft-argmax function , where , takes a vector and computes each component of the vector by

Note in particular that for any .

We also define for any with positive coordinates¹, i.e., , for all , the function as

Last but not least, we introduce the real valued log-sum-exp function (or weighted softmax), defined for any vector by

Variational formulation

In this note we show that the soft-argmax function can be written as the conjugate of the log-sum-exp function.

The following limit properties for infinitesimal explain the naming and the regularizing property of the (temperature) parameter :

The first limit show that the soft-argmax function is a kind of smooth approximation of the argmax function, while the log-sum-exp function is a smooth approximation of the max function.

Invariance properties

The softmax function is invariant to the addition of a constant to each component of the input vector. More precisely, we have the following result:

Let us consider also the effect of rescaling the input vector by a positive constant. We have the following result:

Visualization

We consider the case for visualization.

You can click on the plot to move (the purple dot), and see the corresponding soft-argmax (the red dot). You can modify (the black dot) and with the slider. The level sets displayed are for the function after the max in the log-sum-exp definition, i.e., for a fixed , and , the level set is the set of points such that

d3 = require("d3@v6", "d3-hexbin@0.2")
math = require("mathjs")
digamma = require( 'https://cdn.jsdelivr.net/gh/stdlib-js/math-base-special-digamma@umd/browser.js' )

import {legend} from "@d3/color-legend"


densityResolution = 80
margin = ({ left: 30, top: 30, right: 30, bottom: 30 })
height = 400



beta = [inputs.beta]
// lbd = [0.3,0.3,0.4]

viewof q1 = Inputs.range([0.01, 1], {value: 1/3, label: tex`q_1`, step: 0.01})
viewof q2 = Inputs.range([0.01, 1], {value: 1/3, label: tex`q_2`, step: 0.01})
viewof q3 = Inputs.range([0.01, 1], {value: 1/3, label: tex`q_3`, step: 0.01})
viewof z1 = Inputs.range([-10, 10], {value: 0.4, label: tex`z_1`, step: 0.01})
viewof z2 = Inputs.range([-10, 10], {value: 0.2, label: tex`z_2`, step: 0.01})
viewof z3 = Inputs.range([-10, 10], {value: 0.2, label: tex`z_3`, step: 0.01})


viewof inputs = Inputs.form({
  z1: viewof z1,
  z2: viewof z2,
  z3: viewof z3,
  beta: Inputs.range([0.01, 10], {value: 1, label: tex`\beta`, step: 0.01}),
  q1: viewof q1,
  q2: viewof q2,
  q3: viewof q3,
})

q = [q1, q2, q3]
z = [z1, z2, z3]

logsumexp = (x, alpha, beta) => {
  let result = 0;
  for(let i = 0; i < x.length; i++) result += alpha[i] * Math.exp(x[i] / beta);
  return beta * Math.log(result);
}


objective = (x, z, alpha, beta) => {
  let result = 0;
  for(let i = 0; i < x.length; i++) result -= beta * x[i] * Math.log(x[i] / alpha[i]);
  for(let i = 0; i < x.length; i++) result += x[i] * z[i];
  return result;
}


kull_leibler = (x, alpha, beta) => {
  let result = 0;
  for(let i = 0; i < x.length; i++) result -= x[i] * Math.log(x[i] / alpha[i]);
  return beta * result;
}


softmax = (x, alpha, beta) => {
  let result = [];
  let sum = 0;
  for(let i = 0; i < x.length; i++) {
    result.push(alpha[i] * Math.exp(x[i] / beta));
    sum += result[i];
  }
  for(let i = 0; i < x.length; i++) result[i] /= sum;
  return result;
}

function cartesianToBarycentric(x, y, corners) {
  const A = corners[0], B = corners[1], C = corners[2];
  const v0 = { x: C.x - A.x, y: C.y - A.y };
  const v1 = { x: B.x - A.x, y: B.y - A.y };
  const v2 = { x: x - A.x, y: y - A.y };

  const d00 = dot(v0, v0);
  const d01 = dot(v0, v1);
  const d11 = dot(v1, v1);
  const d20 = dot(v2, v0);
  const d21 = dot(v2, v1);
  const denom = d00 * d11 - d01 * d01;

  const lambda1 = (d11 * d20 - d01 * d21) / denom;
  const lambda2 = (d00 * d21 - d01 * d20) / denom;
  const lambda3 = 1.0 - lambda1 - lambda2;

  return [lambda1, lambda2, lambda3];
}

function barycentricToCartesian(q, corners) {
  return [
    corners[0].x * q[0] + corners[1].x * q[1] + corners[2].x * q[2],
    corners[0].y * q[0] + corners[1].y * q[1] + corners[2].y * q[2]
  ];
}

function dot(v1, v2) {
  return v1.x * v2.x + v1.y * v2.y;
}

ternaryDensity = (density, resolution, options, lbd) => {
  options = Object.assign({
    size: 400,
    margin: { left: 30, top: 30, right: 30, bottom: 30 },
    colorScheme: d3.interpolateBlues
  }, options);


  const fillScale = d3.scaleSequential(options.colorScheme).domain([0
  , Math.log(Math.max(q[0],q[1],q[2]))]);
  // const fillScale = d3.scaleSequential(options.colorScheme).domain(d3.extent(density.map(d => d.density)))

  const svg = d3.create("svg")
    .attr("width", options.size)
    .attr("height", options.size);

  const x = d3.scaleLinear()
    .domain([0, 1])
    .range([options.margin.left, options.size - options.margin.right])

  const y = d3.scaleLinear()
    .domain([0, 1])
    .range([options.size - options.margin.bottom, options.margin.top]);


  function inverseScaleX(value) {
    // Constants from the original scale
    const domainMin = 0;
    const domainMax = 1;
    const rangeMin = options.margin.left;
    const rangeMax = options.size - options.margin.right;

    // Calculate the proportion of the input value within the range
    const proportion = (value - rangeMin) / (rangeMax - rangeMin);

    // Apply the proportion to the domain
    return proportion * (domainMax - domainMin) + domainMin;
  }

  function inverseInverseScaleX(value) {
    // Constants from the original scale
    const domainMin = 0;
    const domainMax = 1;
    const rangeMin = options.size - options.margin.right;
    const rangeMax = options.margin.left;

    // Calculate the proportion of the input value within the range
    const proportion = (rangeMax - rangeMin);

    // Apply the proportion to the domain
    return rangeMax - proportion * value ;
  }

  function inverseScaleY(value) {
    // Constants from the original scale
    const domainMin = 0;
    const domainMax = 1;
    const rangeMin = options.size - options.margin.bottom;
    const rangeMax = options.margin.top;

    // Calculate the proportion of the input value within the range
    const proportion = (value - rangeMin) / (rangeMax - rangeMin);


    // Apply the proportion to the domain
    return proportion * (domainMax - domainMin) + domainMin;
  }

  function inverseInverseScaleY(value) {
    // Constants from the original scale
    const domainMin = 0;
    const domainMax = 1;
    const rangeMin = options.size - options.margin.bottom;
    const rangeMax = options.margin.top;

    // Calculate the proportion of the input value within the range
    const proportion = (rangeMax - rangeMin);

    // Apply the proportion to the domain
    return proportion * value + rangeMin;
  }



  const axisBottom = g => g.call(d3.axisBottom(x).ticks(4))
  const axisTop = g => g.call(d3.axisTop(x).ticks(4));

  const hexagonSize = ((x(1 / (2 * resolution)) - x(0))) / Math.cos(Math.PI / 6) + 1;

  const corners = [{ x: 0.5, y: Math.sqrt(3)/2 }, { x: 0, y: 0 }, {x: 1, y: 0 }];
  const corners_expanded = [{ x: 0.5, y: Math.sqrt(3)/2 + 0.1 }, { x: -0.1, y: -0.05 }, {x: 1.1, y: -0.05 }];

  const line = d3.line().x(d => x(d.x)).y(d => y(d.y));

  svg.append('defs')
    .append('clipPath')
    .attr('id', 'triangle')
    .append('path')
    .attr('x', options.size / 2)
    .attr('y', options.size / 2)
    .attr('d', line(corners))

  svg.selectAll('.border')
    .data([[corners[0], corners[1]],
           [corners[1], corners[2]],
           [corners[2], corners[0]]])
    .enter()
    .append('line')
    .attr('x1', (d) => x(d[0].x))
    .attr('x2', (d) => x(d[1].x))
    .attr('y1', (d) => y(d[0].y))
    .attr('y2', (d) => y(d[1].y))
    .attr('class', 'border')
    .attr('stroke', 'black');

  const hexbin = d3.hexbin();

  svg.append('g')
    .attr('clip-path', 'url(#triangle)')
    .selectAll(".point")
    .data(density)
    .join('path')
    .attr('transform', d => `translate(${x(corners[0].x * d.x[0] + corners[1].x * d.x[1] + corners[2].x * d.x[2])}, ${y(corners[0].y * d.x[0] + corners[1].y * d.x[1] + corners[2].y * d.x[2])})`)
    .attr('fill', d => fillScale(d.density))
    .attr('d', hexbin.hexagon(hexagonSize));

  svg.selectAll('text')
    .data([[corners_expanded[0], corners_expanded[1]],
           [corners_expanded[1], corners_expanded[2]],
           [corners_expanded[2], corners_expanded[0]]])
    .join("text")
    .attr("text-anchor", "middle")
    .attr("alignment-baseline", "middle")
    .attr("font-style", "italic")
    .attr("x", d => (x(d[0].x) + x(d[1].x)) / 2)
    .attr("y", d => (y(d[0].y) + y(d[1].y)) / 2)
    .text((d, i) => {
      if(i == 0) return "x₂" ;
      if(i == 1) return "x₃";
      if(i == 2) return "x₁";
    })

    let xy = barycentricToCartesian(z, corners)
    let xyr = [inverseInverseScaleX(xy[0]), inverseInverseScaleY(xy[1])];

    let xy_q = barycentricToCartesian(q, corners)
    let xyr_q = [inverseInverseScaleX(xy_q[0]), inverseInverseScaleY(xy_q[1])];

    let sftmax = softmax([z1, z2, z3], q, beta)
    let xy_s = barycentricToCartesian(sftmax, corners)
    let xyr_s = [inverseInverseScaleX(xy_s[0]), inverseInverseScaleY(xy_s[1])];

    // If it does not exist, append a new red circle
    svg.append("circle")
      .attr("class", "red-circle") // Add a class for easy selection
      .attr("cx", xyr_s[0])
      .attr("cy", xyr_s[1])
      .attr("z-index", 1000)
      .attr("r", 7) // Radius of the circle
      .attr("fill", "red"); // Fill color of the circle

    svg.append("circle")
      .attr("class", "purple-circle") // Add a class for easy selection
      .attr("cx", xyr[0])
      .attr("cy", xyr[1])
      .attr("z-index", 1000)
      .attr("r", 7) // Radius of the circle
      .attr("fill", "purple"); // Fill color of the circle


    svg.append("circle")
      .attr("class", "black-circle") // Add a class for easy selection
      .attr("cx", xyr_q[0])
      .attr("cy", xyr_q[1])
      .attr("z-index", 1000)
      .attr("r", 7) // Radius of the circle
      .attr("fill", "black"); // Fill color of the circle


    // Append text for the coordinates
    svg.append("text")
      .attr("class", "coord-text") // Add a class for easy selection
      // .attr("x", xyr[0] + 10) // Position the text right next to the circle
      // .attr("y", xyr[1])
      .attr("x", 300) // Position the text right next to the circle
      .attr("y", 80)
      .attr("fill", "black") // Text color
      .style("font-size", "10px")
      .text(`q=(${q[0].toFixed(2)}, ${q[1].toFixed(2)}, ${q[2].toFixed(2)})`); // Display coordinates
    // Append color legend for purple-circle and red-circle:


    // Append text for the coordinates
    svg.append("text")
      .attr("class", "coord-text") // Add a class for easy selection
      // .attr("x", xyr[0] + 10) // Position the text right next to the circle
      // .attr("y", xyr[1])
      .attr("x", 300) // Position the text right next to the circle
      .attr("y", 100)
      .attr("fill", "red") // Text color
      .style("font-size", "10px")
      .text(`σ_{q,β}=(${sftmax[0].toFixed(2)}, ${sftmax[1].toFixed(2)}, ${sftmax[2].toFixed(2)})`); // Display coordinates
    // Append color legend for purple-circle and red-circle:

    svg.append("text")
      .attr("class", "coord-text") // Add a class for easy selection
      .attr("x", 300) // Position the text right next to the circle
      .attr("y", 120)
      .attr("fill", "purple") // Text color
      .style("font-size", "10px")
      .text(`z=(${z1.toFixed(2)}, ${z2.toFixed(2)}, ${z3.toFixed(2)})`); // Display coordinates


  const removeLine = g => g.select(".domain").remove();

function set(input, value) {
  input.value = value;
  input.dispatchEvent(new Event("input", {bubbles: true}));
}

// Attach a click event listener to the SVG
svg.on("click", function(event) {
  // Extract the click coordinates
  const [clickX, clickY] = d3.pointer(event);
  lbd = cartesianToBarycentric(inverseScaleX(clickX), inverseScaleY(clickY), corners);

  set(viewof z1, lbd[2]);
  set(viewof z2, lbd[1]);
  set(viewof z3, lbd[0]);
});

 // display axis values
svg.append("g")
    .attr("transform", `translate(0, ${options.size - options.margin.bottom})`)
    .call(axisBottom)
    .call(removeLine)

  svg.append("g")
    .attr("transform", `translate(${x(1) + options.margin.right / 2 }, ${y(0) + 26}) rotate(-120)`)
    .call(axisBottom)
    .call(removeLine)
    .call(g => g.selectAll("text").attr("transform", "translate(11, 22) rotate(120)"));

  svg.append("g")
    .attr("transform", `translate(${x(0.5) + options.margin.left / 2}, ${y(Math.sqrt(3) / 2) - 26}) rotate(120)`)
    .call(axisBottom)
    .call(removeLine)
    .call(g => g.selectAll("text").attr("transform", "translate(-11, 22) rotate(-120)"));

  return svg.node();
}


levelLogsumexp = {
  const density = [];
  for(let i = 1; i < densityResolution; i++) {
    for(let j = 1; j < densityResolution - i; j++) {
      const x1 = i / densityResolution ;
      const x2 = j / densityResolution;
      const x3 = Math.max(0, 1 - x1 - x2);
      const x = [ x1, x2, x3 ];

      density.push({ x, density: logsumexp(x, q, beta) });
    }
  }
  return density;
}

levelKL = {
  const density = [];
  for(let i = 1; i < densityResolution; i++) {
    for(let j = 1; j < densityResolution - i; j++) {
      const x1 = i / densityResolution ;
      const x2 = j / densityResolution;
      const x3 = Math.max(0, 1 - x1 - x2);
      const x = [ x1, x2, x3 ];

      // density.push({ x, density: logsumexp(x, q, beta) / Math.log(Math.max(q[0],q[1], q[2]) * Math.exp(1/beta)) });
      density.push({ x, density: kull_leibler(x, q, beta) });
    }
  }
  return density;
}


levelKL_full = {
  const density = [];
  for(let i = 1; i < densityResolution; i++) {
    for(let j = 1; j < densityResolution - i; j++) {
      const x1 = i / densityResolution ;
      const x2 = j / densityResolution;
      const x3 = Math.max(0, 1 - x1 - x2);
      const x = [ x1, x2, x3 ];

      // density.push({ x, density: logsumexp(x, q, beta) / Math.log(Math.max(q[0],q[1], q[2]) * Math.exp(1/beta)) });
      density.push({ x, density: objective(x, z, q, beta) });
    }
  }
  return density;
}

ternaryDensity(levelKL_full, densityResolution, { size: 500, colorScheme: d3.interpolateBlues})
logsumexpColorScale = legend({color: d3.scaleSequential(d3.extent([0,  logsumexp(z, q, beta)]), d3.interpolateBlues), title: "Intensity"})

Credit

• The observable code was made with the help of François-David Collin

• The plot is freely inspired from Herb Susmann’s code on Dirichlet Distribution

• The terminology is inspired by posts from Gabriel Peyré: https://x.com/gabrielpeyre/status/1830470713041354968, https://x.com/gabrielpeyre/status/1680804520862056448

References