cum_sum with lit gives random incorrect results

[xbr32]

Checks

• I have checked that this issue has not already been reported.
• I have confirmed this bug exists on the latest version of Polars.

Reproducible example

import polars as pl

print(
    pl.DataFrame({
        "group": ["a", "a", "a", "b", "b", "a"]
    })
    .with_columns(pl.lit(1).cum_sum().over("group").alias("cum_sum"))
)

Log output

shape: (6, 2)
┌───────┬─────────┐
│ group ┆ cum_sum │
│ ---   ┆ ---     │
│ str   ┆ i32     │
╞═══════╪═════════╡
│ a     ┆ 1       │
│ a     ┆ 0       │
│ a     ┆ 1       │
│ b     ┆ 0       │
│ b     ┆ 2       │
│ a     ┆ 0       │
└───────┴─────────┘

Issue description

The results are wrong and are random. I get different values if I try on another computer.
Correct results are below in "expected behavior".

Expected behavior

shape: (6, 2)

group	cum_sum
str	i32
"a"	1
"a"	2
"a"	3
"b"	1
"b"	2
"a"	4

Installed versions

Details

--------Version info---------
Polars:              1.38.1
Index type:          UInt32
Platform:            Linux-6.18.8-1.surface.fc43.x86_64-x86_64-with-glibc2.42
Python:              3.13.11 (main, Nov 10 2011, 15:00:00) [GCC 15.2.0]
Runtime:             rt32

----Optional dependencies----
Azure CLI            <not installed>
adbc_driver_manager  <not installed>
altair               <not installed>
azure.identity       <not installed>
boto3                <not installed>
cloudpickle          <not installed>
connectorx           <not installed>
deltalake            <not installed>
fastexcel            <not installed>
fsspec               <not installed>
gevent               <not installed>
google.auth          <not installed>
great_tables         <not installed>
matplotlib           <not installed>
numpy                <not installed>
openpyxl             <not installed>
pandas               <not installed>
polars_cloud         <not installed>
pyarrow              <not installed>
pydantic             <not installed>
pyiceberg            <not installed>
sqlalchemy           <not installed>

[kdn36]

Triage notes for comparison and follow-up.. this one produces the expected result:

import polars as pl

df = pl.DataFrame({
        "group": ["a", "a", "a", "b", "b", "a"],
        "one": [1 for _ in range(6)]
    }
)

q = df.lazy().with_columns(pl.col.one.cum_sum().over("group").alias("cum_sum"))
print(q.collect())

gives

shape: (6, 3)
┌───────┬─────┬─────────┐
│ group ┆ one ┆ cum_sum │
│ ---   ┆ --- ┆ ---     │
│ str   ┆ i64 ┆ i64     │
╞═══════╪═════╪═════════╡
│ a     ┆ 1   ┆ 1       │
│ a     ┆ 1   ┆ 2       │
│ a     ┆ 1   ┆ 3       │
│ b     ┆ 1   ┆ 1       │
│ b     ┆ 1   ┆ 2       │
│ a     ┆ 1   ┆ 4       │
└───────┴─────┴─────────┘

[kdn36]

Also note, without groups:

import polars as pl

df = pl.DataFrame({"one": [1 for _ in range(3)]})

q = df.lazy().with_columns(pl.col.one.cum_sum().alias("cum_sum"))
out = q.collect()
print(out)

q = df.lazy().with_columns(pl.lit(1).cum_sum().alias("cum_sum"))
out = q.collect()
print(out)

gives

shape: (3, 2)
┌─────┬─────────┐
│ one ┆ cum_sum │
│ --- ┆ ---     │
│ i64 ┆ i64     │
╞═════╪═════════╡
│ 1   ┆ 1       │
│ 1   ┆ 2       │
│ 1   ┆ 3       │
└─────┴─────────┘
shape: (3, 2)
┌─────┬─────────┐
│ one ┆ cum_sum │
│ --- ┆ ---     │
│ i64 ┆ i32     │
╞═════╪═════════╡
│ 1   ┆ 1       │
│ 1   ┆ 1       │
│ 1   ┆ 1       │
└─────┴─────────┘

[kdn36]

Clarification on the expected behavior: a unary expression on a literal does not trigger broadcast logic, hence lit(a).unary_expr() -> lit(b).

For the initial case of over, this is not as expected (1, 0, etc), and fixed in the PR. The expected result in the case of over, is

shape: (6, 2)
┌───────┬─────────┐
│ group ┆ cum_sum │
│ ---   ┆ ---     │
│ str   ┆ i32     │
╞═══════╪═════════╡
│ a     ┆ 1       │
│ a     ┆ 1       │
│ a     ┆ 1       │
│ b     ┆ 1       │
│ b     ┆ 1       │
│ a     ┆ 1       │
└───────┴─────────┘

For the case of no over, what we see is as expected.