q =df.lazy().with_column(pl.when(pl.col("a")>pl.col("b")).then(pl.col("b")).otherwise(pl.col("a")).alias("minimum"))

df = q.collect()

i didn't tested it but this should work i think

As the accepted answer states, you can use pl.when -> then -> otherwise expression.

If you have a wider DataFrame, you can use the DataFrame.min() method, pl.min expression, or a pl.fold for more control.

import polars as pl

df = pl.DataFrame({
    "a": [1,4,2,5,2],
    "b": [5,1,4,2,5],
    "c": [3,2,5,7,2]
})

df.min(axis=1)

This outputs:

shape: (5,)
Series: 'a' [i64]
[
    1
    1
    2
    2
    2
]

Min expression

When given multiple expression inputs to a pl.min the minimum is determined row-wise instead of column-wise.

df.select(pl.min(["a", "b", "c"]))

Outputs:

shape: (5, 1)
┌─────┐
│ min │
│ --- │
│ i64 │
╞═════╡
│ 1   │
├╌╌╌╌╌┤
│ 1   │
├╌╌╌╌╌┤
│ 2   │
├╌╌╌╌╌┤
│ 2   │
├╌╌╌╌╌┤
│ 2   │
└─────┘

Fold expression

Or with a fold expression:

df.select(
    pl.fold(int(1e9), lambda acc, a: pl.when(acc > a).then(a).otherwise(acc), ["a", "b", "c"])
)

shape: (5, 1)
┌─────────┐
│ literal │
│ ---     │
│ i64     │
╞═════════╡
│ 1       │
├╌╌╌╌╌╌╌╌╌┤
│ 1       │
├╌╌╌╌╌╌╌╌╌┤
│ 2       │
├╌╌╌╌╌╌╌╌╌┤
│ 2       │
├╌╌╌╌╌╌╌╌╌┤
│ 2       │
└─────────┘

The fold allows for more cool things, because you operate over expressions.

So we could for instance compute the min of the squared columns:

pl.fold(int(1e9), lambda acc, a: pl.when(acc > a).then(a).otherwise(acc), [pl.all()**2])

Or we could compute the min of square root of column "a" and the rest of the columns is squared.

pl.fold(int(1e9), lambda acc, a: pl.when(acc > a).then(a).otherwise(acc), [pl.col("a").sqrt(), pl.all().exclude("a")**2])

You get the idea.