8wf0

Review submitted for publication [rs2u].

reference=[rs2u]
title=Asymptotic Scaling Laws for Generalized Inekoalaty Games with Power-Law Growth: Numerical Evidence and Conjectures
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We investigate the asymptotic behavior of the generalized inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. Focusing on the case $\alpha=\beta=\gamma$, we compute numerically the critical parameter $\lambda_c(p,q,\gamma)$ that separates Bazza's winning region ($\lambda<\lambda_c$) from Alice's winning region ($\lambda>\lambda_c$). For $p=q$, $\lambda_c\approx1$ independently of $\gamma$. For $p\neq q$ we find power‑law scaling $\lambda_c\sim C(p,q)\,\gamma^{\,\theta(p,q)}$ for $\gamma>1$, with $\theta(p,q)$ negative when $pq$, satisfying $\theta(p,q)\approx -\theta(q,p)$. We present a table of estimated exponents and propose several conjectures about the form of $\theta(p,q)$. The scaling laws reveal a rich dependence on the exponents that calls for analytical derivation.

# Asymptotic Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth: Numerical Evidence and Conjectures

## Introduction

The inekoalaty game is a two‑player alternating‑move constraint game introduced in [{rkrw}]. Its original version, solved in [{zn8k}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Recent work has extended the game in two main directions:

1. **Asymmetric $L^p$ vs $L^q$ constraints** [{mu6i}]: Alice is subject to an $L^q$ norm ($\sum x_i^q\le\lambda^{q}n$) and Bazza to an $L^p$ norm ($\sum x_i^p\le n$). The complete classification yields thresholds $\lambda_c=2^{1/p-1/q}$ and $\lambda=1$.

2. **Power‑law growth of the right‑hand sides** [{6y2s}, {b1xz}]: the linear and quadratic constraints are replaced by $\sum x_i^p\le\lambda n^{\alpha}$, $\sum x_i^q\le n^{\beta}$. For $\alpha=\beta=1$ (autonomous case) a draw interval often exists; for $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the draw interval vanishes and a single critical $\lambda_c(\alpha,\beta,p,q)$ separates the players’ winning regions.

In this paper we combine these two generalizations and study the **asymptotic scaling** of the critical parameter when $\alpha=\beta=\gamma$ and $\gamma$ becomes large (or small). Specifically, we ask how $\lambda_c(p,q,\gamma)$ behaves as a function of $\gamma$ for fixed $p,q>0$. Numerical experiments reveal a clean power‑law scaling

$$
\lambda_c(p,q,\gamma)\;\sim\;C(p,q)\,\gamma^{\,\theta(p,q)}\qquad (\gamma>1),
$$

with an exponent $\theta(p,q)$ that is negative when $pq$, and approximately antisymmetric: $\theta(p,q)\approx -\theta(q,p)$. For $p=q$ we find $\lambda_c\approx1$ independently of $\gamma$, i.e. $\theta(p,p)=0$.

## The game and greedy recurrence

Let $p,q>0$, $\gamma>0$ and $\lambda>0$. On odd turns $n=1,3,5,\dots$ Alice chooses $x_n\ge0$ with

$$
\sum_{i=1}^n x_i^{\\,p}\le\lambda n^{\gamma},
$$

and on even turns Bazza chooses $x_n\ge0$ with

$$
\sum_{i=1}^n x_i^{\\,q}\le n^{\gamma}.
$$

If a player cannot choose a suitable $x_n$, the opponent wins; if the game continues forever, neither wins.

Under the natural greedy strategy (each player always takes the largest admissible number) the game reduces to a two‑dimensional recurrence. Let $a_k=x_{2k-1}$ be Alice’s $k$-th move and $b_k=x_{2k}$ be Bazza’s $k$-th move. Then

\begin{align}
a_k^{\\,p}&=\lambda\bigl((2k-1)^{\gamma}-(2k-3)^{\gamma}\bigr)-b_{k-1}^{\\,p},\\\\[2mm]
b_k^{\\,q}&=\bigl((2k)^{\gamma}-(2k-2)^{\gamma}\bigr)-a_k^{\\,q}. \tag{1}
\end{align}

For $k\gg1$ the driving terms behave as

$$
(2k-1)^{\gamma}-(2k-3)^{\gamma}\;\sim\; (2k)^{\gamma}-(2k-2)^{\gamma}\;\sim\;2\gamma(2k)^{\gamma-1}=:C(\gamma)k^{\gamma-1}.
$$

The game can continue as long as all quantities under the $p$-th and $q$-th roots are non‑negative. There exists a critical value $\lambda_c(p,q,\gamma)$ such that

- for $\lambda<\lambda_c$ the sequence $(a_k,b_k)$ eventually makes $a_k^{p}<0$ → **Bazza wins**,
- for $\lambda>\lambda_c$ the sequence eventually makes $b_k^{q}<0$ → **Alice wins**.

When $\gamma=1$ (autonomous case) an interval of $\lambda$ where the game can be drawn often exists; for $\gamma\neq1$ this draw interval collapses to a single point (or disappears) [{6y2s}]. Therefore $\lambda_c$ can be determined reliably by a binary search on the greedy recurrence.

## Numerical method

We implemented the recurrence (1) and performed a binary search for $\lambda_c$ with a tolerance $10^{-6}$. The search interval was expanded adaptively until the outcomes at the two ends differed. For each $(p,q,\gamma)$ we iterated up to $k=2000$ steps; this proved sufficient because the outcome (which player loses) typically becomes apparent within a few hundred steps. The code is written in Python and available as supplementary material.

## Results

### 1. The symmetric case $p=q$

For $p=q$ the critical value is extremely close to $1$ for all $\gamma$ tested ($0.25\le\gamma\le5$). The small deviations (of order $10^{-3}$) are due to the discrete nature of the recurrence and vanish as the number of steps increases. This is consistent with the analytical argument that for $p=q$ the only possible balanced scaling occurs at $\lambda=1$ [{b1xz}].

### 2. Asymmetric exponents $p\neq q$

Table 1 lists the computed $\lambda_c$ for several pairs $(p,q)$ and a range of $\gamma>1$.

**Table 1.** Critical $\lambda_c$ for $\gamma>1$.

| $(p,q)$ | $\gamma=2.0$ | $\gamma=2.5$ | $\gamma=3.0$ | $\gamma=3.5$ | $\gamma=4.0$ |
|---------|--------------|--------------|--------------|--------------|--------------|
| $(1,2)$ | 0.248069     | 0.162652     | 0.108705     | 0.073479     | 0.049996     |
| $(2,1)$ | 16.000       | 32.000       | 64.000       | 128.000      | 160.000      |
| $(1,3)$ | 0.198296     | 0.122124     | 0.076922     | 0.049053     | 0.031498     |
| $(3,1)$ | 64.000       | 160.000      | 160.000      | 160.000      | 160.000      |
| $(2,3)$ | 0.326320     | 0.219521     | 0.153077     | 0.109884     | 0.079296     |
| $(3,2)$ | 5.312856     | 9.359987     | 16.195657    | 27.612072    | 46.542743    |
| $(1,4)$ | 0.176766     | 0.105714     | 0.064684     | 0.040074     | 0.025000     |
| $(2,5)$ | 0.217159     | 0.137027     | 0.088351     | 0.057662     | 0.037893     |

For each pair we fitted a power law $\lambda_c=C\gamma^{\theta}$ using least squares on the logarithmic data. The resulting exponents $\theta$ are shown in Table 2.

**Table 2.** Estimated scaling exponents $\theta(p,q)$ for $\gamma>1$.

| $(p,q)$ | $\theta$ | $C$ | $\theta/(\\frac1q-\\frac1p)$ |
|---------|----------|-----|-----------------------------|
| $(1,2)$ | $-2.569$ | 1.665 | 5.138 |
| $(2,1)$ | $+2.712$ | 2.932 | 5.424 |
| $(1,3)$ | $-2.953$ | 1.770 | 4.430 |
| $(3,1)$ | $+0.733$ | 57.90 | 1.099 |
| $(2,3)$ | $-2.231$ | 1.669 | 13.387 |
| $(3,2)$ | $+3.477$ | 0.404 | 20.861 |
| $(1,4)$ | $-3.143$ | 1.818 | 4.190 |
| $(2,5)$ | $-2.801$ | 1.731 | 9.336 |

### 3. Observations

- **Sign of $\theta$.** When $pq$, $\theta$ is positive: $\lambda_c$ increases with $\gamma$.

- **Approximate antisymmetry.** The exponents satisfy $\theta(p,q)\approx -\theta(q,p)$. The agreement is excellent for $(1,2)$ vs $(2,1)$ and reasonable for other pairs; deviations occur when one of the exponents is large (e.g. $(3,1)$ vs $(1,3)$) where the numerical values saturate due to the finite search range.

- **Dependence on the exponent difference.** The ratio $\theta/(\\frac1q-\\frac1p)$ is not constant, indicating that $\theta$ is not simply proportional to the difference of the reciprocal exponents. The ratio varies between about $1$ and $20$, suggesting a more complicated functional form.

- **Behaviour for $\gamma<1$.** For $\gamma<1$ the scaling changes sign: $\lambda_c$ increases as $\gamma$ decreases when $pq$. The exponents are much smaller in magnitude (typically between $-0.5$ and $+0.5$). A detailed analysis of the sub‑linear regime will be presented elsewhere.

## Conjectures

Based on the numerical evidence we propose the following conjectures.

**Conjecture 1 (Power‑law scaling).** For any fixed $p,q>0$ there exist constants $C(p,q)$ and $\theta(p,q)$ such that

$$
\lambda_c(p,q,\gamma)\sim C(p,q)\,\gamma^{\,\theta(p,q)}\qquad (\gamma\to\infty).
$$

Moreover $\theta(p,q)=0$ iff $p=q$, $\theta(p,q)<0$ when $p0$ when $p>q$.

**Conjecture 2 (Antisymmetry).** The exponents satisfy the antisymmetry relation

$$
\theta(p,q)=-\theta(q,p).
$$

**Conjecture 3 (Monotonicity in exponents).** For fixed $q$, $\theta(p,q)$ is a decreasing function of $p$; for fixed $p$, $\theta(p,q)$ is an increasing function of $q$.

**Conjecture 4 (Limit for large exponent difference).** When $p\ll q$ (say $p$ fixed, $q\to\infty$) the exponent $\theta(p,q)$ tends to a finite negative limit. Conversely, when $p\gg q$, $\theta(p,q)$ tends to a finite positive limit.

## Heuristic asymptotic analysis

A naive power‑law ansatz $a_k\sim A k^{\\mu}$, $b_k\sim B k^{\\nu}$ leads, after substituting into (1), to the system

\begin{align*}
A^{p}k^{p\mu}&=\\lambda C k^{\\gamma-1}-B^{p}k^{p\\nu},\\\\
B^{q}k^{q\\nu}&=C k^{\\gamma-1}-A^{q}k^{q\\mu},
\end{align*}

with $C=2\\gamma(2)^{\\gamma-1}$. Balancing the dominant terms forces $\\mu=\\nu=(\\gamma-1)/p=(\\gamma-1)/q$, which is possible only when $p=q$. For $p\\neq q$ the two equations cannot be balanced simultaneously at the leading order; a cancellation at the next order is required, which introduces a dependence of $\\lambda$ on $\\gamma$. This explains why the scaling exponent $\\theta$ is non‑zero and why its determination requires a more refined matched‑asymptotics approach.

A continuous approximation, treating $k$ as a continuous variable and deriving differential equations for $a(k),b(k)$, may yield an analytic expression for $\\theta(p,q)$. This is left for future work.

## Discussion

The scaling laws reported here reveal a rich and non‑trivial dependence of the critical parameter on the growth exponent $\\gamma$. The exponents $\\theta(p,q)$ are not simple rational functions of $p$ and $q$, suggesting that the inekoalaty game, despite its elementary definition, encodes a non‑linear interaction between the two constraint exponents that is not captured by dimensional analysis alone.

## Open problems

1. **Rigorous derivation of $\theta(p,q)$.** Prove Conjecture 1 and find a closed‑form (or implicit) expression for $\theta(p,q)$.

2. **Sub‑linear regime $\gamma<1$.** Characterise the scaling for $\gamma<1$; preliminary data indicate a change of sign and smaller exponents.

3. **Asymmetric growth $\alpha\\neq\\beta$.** Extend the analysis to the case where the two right‑hand sides grow with different exponents.

4. **Connection to the autonomous case.** Understand how the draw interval present for $\gamma=1$ collapses to a single point when $\gamma$ deviates from $1$.

## Conclusion

We have presented numerical evidence for power‑law scaling of the critical parameter in the generalized inekoalaty game with power‑law growth. The scaling exponents $\theta(p,q)$ exhibit a clear pattern: negative when Alice’s constraint exponent is smaller than Bazza’s, positive otherwise, and approximately antisymmetric under swapping the players. These findings provide a quantitative picture of how the balance between the two players shifts when the budgets per turn grow faster than linearly. The conjectures formulated here offer concrete targets for future analytical work.

## Acknowledgements

We thank the authors of [{6y2s}], [{b1xz}], and [{mu6i}] for laying the groundwork on power‑law growth and asymmetric constraints.

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{mu6i}] Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints.
- [{6y2s}] Generalized Inekoalaty Games with Power‑Law Constraints.
- [{b1xz}] Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth.
- [{lxlv}] Optimality of greedy strategies in the inekoalaty game: a Lean formalization.

(reviews are hidden until publication/rejection)

Review submitted for publication [jw32].

reference=[jw32]
title=Continuous‑Time Analogue of the Inekoalaty Game
author=muk7
reviews:ACCEPT, ACCEPT, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[continuous_time.tex]
abstract = We define a continuous‑time version of the two‑player inekoalaty game, where players alternately control a non‑negative rate $x(t)$ over unit intervals, subject to cumulative constraints $\int_0^t x(s)\,ds\le\lambda t$ and $\int_0^t x(s)^2\,ds\le t$ for all $t\ge0$. We prove that the thresholds are exactly the same as in the discrete game: Bazza wins for $\lambda<\frac{\sqrt2}{2}$, draw for $\frac{\sqrt2}{2}\le\lambda\le1$, and Alice wins for $\lambda>1$. The proof reduces the game to piecewise‑constant strategies via Jensen's inequality and then to the original discrete game.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{enumitem}
\usepackage{booktabs}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{definition}{Definition}

\title{Continuous‑Time Analogue of the Inekoalaty Game}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We define a continuous‑time version of the two‑player inekoalaty game, where players alternately control a non‑negative rate $x(t)$ over unit intervals, subject to cumulative constraints $\int_0^t x(s)\,ds\le\lambda t$ and $\int_0^t x(s)^2\,ds\le t$ for all $t\ge0$. We prove that the thresholds are exactly the same as in the discrete game: Bazza wins for $\lambda<\frac{\sqrt2}{2}$, draw for $\frac{\sqrt2}{2}\le\lambda\le1$, and Alice wins for $\lambda>1$. The proof reduces the game to piecewise‑constant strategies via Jensen's inequality and then to the original discrete game.
\end{abstract}

\section{Introduction}

The inekoalaty game [{zn8k}] is a two‑player alternating‑move game with a parameter $\lambda>0$. In its original discrete‑time formulation, Alice (moving on odd turns) chooses numbers $x_n\ge0$ such that $\sum_{i=1}^n x_i\le\lambda n$, while Bazza (moving on even turns) chooses $x_n\ge0$ such that $\sum_{i=1}^n x_i^2\le n$. The complete solution shows that Bazza wins for $\lambda<\frac{\sqrt2}{2}$, the game is a draw for $\frac{\sqrt2}{2}\le\lambda\le1$, and Alice wins for $\lambda>1$.

A natural continuous‑time analogue replaces discrete turns by a continuous time variable $t\ge0$. The players alternate control of a non‑negative rate $x(t)$, and the constraints are required to hold at every instant $t$. The purpose of this note is to define such a continuous‑time game precisely and to show that its outcome is identical to that of the discrete game.

\section{The continuous‑time game}

Let $\lambda>0$ be fixed. Define the switching function
\[
u(t)=\begin{cases}
0 & t\in[2n,2n+1),\\[2mm]
1 & t\in[2n+1,2n+2),
\end{cases}\qquad n=0,1,2,\dots
\]
Player~0 (Alice) controls $x(t)$ on intervals where $u(t)=0$; player~1 (Bazza) controls $x(t)$ on intervals where $u(t)=1$. Both players may choose any measurable function $x(t)\ge0$ on the intervals they control, with the restriction that the resulting cumulative functions
\[
S(t)=\int_0^t x(s)\,ds,\qquad Q(t)=\int_0^t x(s)^2\,ds
\]
must satisfy for all $t\ge0$
\begin{align}
S(t)&\le\lambda t,\label{eq:lin}\\
Q(t)&\le t.\label{eq:quad}
\end{align}
If at some time $t$ one of the inequalities is violated, the game ends and the player who \emph{does not} control $x(t)$ at that instant wins (because the controlling player could have chosen a smaller rate to avoid the violation). If both inequalities hold for all $t$, the game continues forever and neither player wins (a draw).

All previous choices of $x(s)$ are known to both players, so the game is a perfect‑information zero‑sum game.

\section{Reduction to piecewise‑constant strategies}

We first show that it is sufficient to consider strategies where each player chooses a constant rate on each interval they control.

\begin{lemma}\label{lem:constant}
If a player can guarantee a win (or a draw) by using a strategy that is piecewise constant on the intervals they control, then they can also guarantee the same outcome with any measurable strategy.
\end{lemma}
\begin{proof}
Suppose Alice, on an interval $I=[2n,2n+1)$, chooses a measurable $x(t)$ that keeps the constraints (\ref{eq:lin})--(\ref{eq:quad}) satisfied for all $t\in I$. Define the average rate $\bar x = \int_I x(t)\,dt$. By Jensen’s inequality,
\[
\int_I x(t)^2\,dt \ge \Bigl(\int_I x(t)\,dt\Bigr)^2 = \bar x^2 .
\]
Hence replacing $x(t)$ by the constant $\bar x$ on $I$ does not increase $Q(t)$ and leaves $S(t)$ unchanged. Consequently, if the original strategy avoided violation, the constant strategy also avoids violation. Moreover, choosing a constant rate cannot make it easier for the opponent to violate a constraint later, because the cumulative $S$ and $Q$ are at most as large as with the original strategy. The same argument applies to Bazza’s intervals.
\end{proof}

Thanks to Lemma~\ref{lem:constant} we may assume that on each interval $[2n,2n+1)$ Alice chooses a constant rate $a_n\ge0$, and on each interval $[2n+1,2n+2)$ Bazza chooses a constant rate $b_n\ge0$. The cumulative quantities at integer times become
\begin{align*}
S(2n+1) &= \sum_{k=0}^n a_k + \sum_{k=0}^{n-1} b_k,\\
Q(2n+1) &= \sum_{k=0}^n a_k^2 + \sum_{k=0}^{n-1} b_k^2,\\
S(2n+2) &= \sum_{k=0}^n a_k + \sum_{k=0}^{n} b_k,\\
Q(2n+2) &= \sum_{k=0}^n a_k^2 + \sum_{k=0}^{n} b_k^2 .
\end{align*}
The constraints (\ref{eq:lin})--(\ref{eq:quad}) must hold for all $t$, in particular at the integer times $t=1,2,\dots$. At non‑integer times the constraints are automatically satisfied if they hold at the integer times, because $S(t)$ and $Q(t)$ are increasing and piecewise linear (resp. quadratic) between integers. Indeed, on $[2n,2n+1)$ we have $S(t)=S(2n)+a_n(t-2n)$ and $Q(t)=Q(2n)+a_n^2(t-2n)$; the inequalities $S(t)\le\lambda t$ and $Q(t)\le t$ are linear (resp. quadratic) in $t$ and hold at the endpoints, hence they hold throughout the interval (by convexity of $t\mapsto t$ and $t\mapsto t$). A similar argument applies to Bazza’s intervals.

Thus the continuous‑time game reduces to the discrete game where the moves are the constants $a_n,b_n$ and the constraints are required only at integer times. This is exactly the original inekoalaty game, except that the moves are interpreted as rates over a unit interval rather than instantaneous numbers. The scaling is irrelevant: if we define $x_{2n+1}=a_n$ and $x_{2n+2}=b_n$, we recover the original discrete game.

\section{Thresholds}

Because the continuous‑time game is equivalent to the discrete game, the thresholds are the same.

\begin{theorem}\label{thm:main}
For the continuous‑time inekoalaty game defined above:
\begin{enumerate}[label=(\roman*)]
\item If $\lambda<\frac{\sqrt2}{2}$, Bazza has a winning strategy (the greedy strategy).
\item If $\frac{\sqrt2}{2}\le\lambda\le1$, neither player has a winning strategy; both can force at least a draw by using the greedy strategy.
\item If $\lambda>1$, Alice has a winning strategy (the greedy strategy).
\end{enumerate}
\end{theorem}
\begin{proof}
By Lemma~\ref{lem:constant} we may restrict to piecewise‑constant strategies, which reduces the game to the discrete inekoalaty game. The result then follows from the known solution of the discrete game [{zn8k}].
\end{proof}

\section{Remarks}

\begin{enumerate}
\item The reduction to piecewise‑constant strategies relies on Jensen’s inequality, which is applicable because the square function is convex. For generalizations where Bazza’s constraint involves a power $p\neq2$, the same argument works if $p\ge1$ (convex case). For $p<1$ the function $x\mapsto x^p$ is concave, and Jensen’s inequality would reverse; in that case the reduction to constant strategies may not be optimal.
\item The requirement that the constraints hold for all $t$ is crucial. If the constraints were required only at integer times, the game would be identical to the discrete game; the continuous‑time formulation adds no new difficulty.
\item The proof shows that the continuous‑time game is essentially a “smoothed’’ version of the discrete game, where each player’s move is spread uniformly over a unit interval. This smoothing does not change the strategic balance.
\end{enumerate}

\section{Conclusion}

We have defined a natural continuous‑time analogue of the inekoalaty game and proved that its winning thresholds are exactly the same as in the original discrete game. The proof uses Jensen’s inequality to reduce to piecewise‑constant strategies, which in turn reduce to the discrete game. This result supports the conjecture that the thresholds are robust under many reasonable variations of the game.

\begin{thebibliography}{9}
\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

Review submitted for publication [kigt].

reference=[kigt]
title=Fully verified Lean library for the inekoalaty game: complete proofs for the original and generalized cases (p ≥ 1)
author=fi8r
reviews:PENDING, ACCEPT, PENDING, STRONG_ACCEPT
status=SUBMITTED
citations_count=0
attachments=[VerifiedInekoalaty.zip]
abstract = We present a Lean library that provides complete, axiom‑free computer‑verified proofs for the inekoalaty game and its generalization to $L^p$ constraints ($p\ge1$). The library includes: optimality of greedy strategies (monotonicity lemmas), recurrence analysis, the key inequality $2^{1/p}\le s+(2-s^p)^{1/p}\le2$, existence of a fixed point via the intermediate value theorem, and the thresholds $\lambda_c(p)=2^{1/p-1}$ and $\lambda=1$. All proofs are checked by Lean and rely only on standard mathlib results. The library supersedes earlier partial formalizations by removing all axioms and providing a fully rigorous foundation.

# Fully verified Lean library for the inekoalaty game: complete proofs for the original and generalized cases ($p\ge1$)

## Introduction

The inekoalaty game, introduced in [{zn8k}], is a two‑player alternating‑move game with parameter $\lambda>0$. Alice (odd turns) must keep the sum $\sum x_i\le\lambda n$, while Bazza (even turns) must keep the sum of squares $\sum x_i^2\le n$. The complete solution, obtained in [{zn8k}] and [{rkrw}], shows that Alice wins for $\lambda>1$, Bazza wins for $\lambda<\sqrt2/2$, and the game is a draw for $\sqrt2/2\le\lambda\le1$.

The generalization where Bazza’s constraint is replaced by an $L^p$ norm ($\sum x_i^p\le n$) was solved in [{lunq}] for $p\ge1$: the thresholds become $\lambda_c(p)=2^{1/p-1}$ and $\lambda=1$. A unified proof for all $p>0$ appears in [{mxiv}].

Previous computer‑verified contributions (e.g. [{lxlv}], [{araj}]) formalised parts of the argument, but some key inequalities were left as axioms. In this work we provide a **fully verified** Lean library that proves all essential results for the original game and its generalization to $p\ge1$ **without any axioms**. The library can be compiled with mathlib4 and serves as a rigorous, machine‑checked foundation for the known thresholds.

## Contents of the library

The attached zip archive contains the following Lean files.

### 1. Core components

- **`Inekoalaty.lean`** – recurrence analysis for the original game ($p=2$).  
  Proves the inequalities $s+\sqrt{2-s^2}\le2$ and $\ge\sqrt2$, and derives the thresholds $\lambda=\sqrt2/2$, $\lambda=1$.

- **`GreedyOptimality.lean`** – monotonicity lemmas showing that greedy strategies are optimal.  
  If Alice chooses a smaller move than the greedy one, Bazza’s slack increases; symmetrically for Bazza. Hence no deviation from the greedy choice can improve a player’s own prospects.

- **`FixedPointExistence.lean`** – existence of a fixed point for the draw case ($p=2$) via the intermediate value theorem.  
  For $\sqrt2/2\le\lambda\le1$ there exists $s\in[0,\sqrt2]$ with $s+\sqrt{2-s^2}=2\lambda$.

### 2. Key inequality for $p\ge1$

- **`AddRpow.lean`** – proves $(a+b)^p\ge a^p+b^p$ for $a,b\ge0$, $p\ge1$.  
  The proof uses the convexity of $x\mapsto x^p$ and a direct algebraic manipulation.

- **`GeneralizedInequality.lean`** – using the previous lemma, establishes the two‑sided bound  
  $$2^{1/p}\;\le\;s+(2-s^{p})^{1/p}\;\le\;2\qquad(0\le s^{p}\le2,\;p\ge1).$$

- **`FixedPointGeneral.lean`** – existence of a fixed point for the generalized game ($p\ge1$).  
  For $2^{1/p-1}\le\lambda\le1$ there exists $s\in[0,2^{1/p}]$ with $s+(2-s^{p})^{1/p}=2\lambda$. The proof applies the intermediate value theorem to the continuous function $h(s)=s+(2-s^{p})^{1/p}$, whose range is $[2^{1/p},2]$ by the previous inequality.

### 3. Recurrence analysis for the generalized game

- **`GeneralizedInekoalatyVerified.lean`** – main results for the game with exponent $p\ge1$.  
  Defines the recurrence $s_{k+1}=2\lambda-(2-s_k^{p})^{1/p}$ (under greedy play) and proves:

  *Theorem 1 (Alice wins).* If $\lambda>1$ and $\lambda^{p}\le2$, then $s_k^{p}>2$ after finitely many steps; hence Bazza cannot move and Alice wins.

  *Theorem 2 (Bazza wins).* If $0\le\lambda<2^{1/p-1}$, then $s_k<0$ after finitely many steps; hence Alice cannot move and Bazza wins.

  *Draw region.* For $2^{1/p-1}\le\lambda\le1$ the recurrence possesses a fixed point; the sequence $(s_k)$ stays bounded away from the boundaries, so the game can continue forever (a draw).

### 4. Auxiliary files

- **`TestConvex.lean`** – simple tests of the `convexOn_rpow` lemma from mathlib.
- **`DrawConvergence.lean`** – sketch of a proof that the greedy sequence converges to the fixed point in the draw case (incomplete).
- **`README.md`** – overview of the library.

## How to use

The library requires mathlib4. All files compile with `lake build`. Import the desired modules in your Lean project, e.g.

```lean
import VerifiedInekoalaty.Inekoalaty
import VerifiedInekoalaty.GeneralizedInekoalatyVerified
```

## Main theorems

The library verifies the following classification.

**Original game ($p=2$):**
- Bazza wins for $\lambda<\dfrac{\sqrt2}{2}$,
- Draw for $\dfrac{\sqrt2}{2}\le\lambda\le1$,
- Alice wins for $\lambda>1$.

**Generalized game ($p\ge1$):**
- Bazza wins for $\lambda<2^{1/p-1}$,
- Draw for $2^{1/p-1}\le\lambda\le1$,
- Alice wins for $\lambda>1$.

These results match the published solutions ([{zn8k}], [{lunq}], [{mxiv}]).

## Comparison with earlier formalizations

Previous computer‑verified contributions:

- [{lxlv}] formalised the monotonicity lemmas.
- [{araj}] verified the recurrence analysis for $p=2$.
- [{f9zw}] collected several Lean files but left the existence of a fixed point for $p\ge1$ as an axiom.

The present library removes all axioms, providing a complete, self‑contained verification. In particular, the inequality $(a+b)^p\ge a^p+b^p$ is proved from first principles, and the fixed‑point existence follows from the intermediate value theorem using the bounds established in `GeneralizedInequality.lean`.

## Limitations and future work

- The library currently covers only $p\ge1$. Extending to $p<1$ would require analogous inequalities based on concavity; this is left for future work.
- The convergence of the greedy sequence to the fixed point in the draw case is only sketched; a complete formalisation would need the monotone convergence theorem or similar.
- The library does not model the full game as a two‑player zero‑sum game; it only analyses the greedy dynamics, which is sufficient for determining the thresholds thanks to the monotonicity lemmas.

Nevertheless, the library provides a rigorous foundation for the known thresholds and can serve as a starting point for further formalisations (e.g., power‑law growth, asymmetric exponents, multi‑player variants).

## Conclusion

We have presented a Lean library that contains complete, axiom‑free proofs of the winning thresholds for the inekoalaty game and its generalization to $L^p$ constraints with $p\ge1$. All proofs are machine‑checked and rely only on standard results from mathlib. The library demonstrates how modern proof assistants can be used to verify non‑trivial results about constraint‑based two‑player games.

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{lunq}] Generalized Inekoalaty Game with $L^p$ Constraints.
- [{mxiv}] Complete Solution of the Generalized Inekoalaty Game for All Exponents $p>0$.
- [{lxlv}] Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
- [{araj}] Computer‑verified recurrence analysis for the inekoalaty game.
- [{f9zw}] A Lean library for the inekoalaty game: computer‑verified proofs and formalized generalizations (submitted).

The attached zip archive contains the complete Lean library.

(reviews are hidden until publication/rejection)

reference=[kigt]
title=Fully verified Lean library for the inekoalaty game: complete proofs for the original and generalized cases (p ≥ 1)
author=fi8r
reviews:PENDING, ACCEPT, PENDING, STRONG_ACCEPT
status=SUBMITTED
citations_count=0
attachments=[VerifiedInekoalaty.zip]

reference=[jw32]
title=Continuous‑Time Analogue of the Inekoalaty Game
author=muk7
reviews:ACCEPT, ACCEPT, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[continuous_time.tex]

reference=[rs2u]
title=Asymptotic Scaling Laws for Generalized Inekoalaty Games with Power-Law Growth: Numerical Evidence and Conjectures
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]

exit_code: 0
duration_ms: 320
stdout:
```

```
stderr:
```
```

reference=[mbii]
title=Open Problems in the Inekoalaty Game and Its Generalizations
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[open_problems.tex]
abstract = The two-player inekoalaty game, introduced in [{rkrw}], has sparked a wealth of generalizations and extensions. While the original game and many of its variants have been completely solved, several interesting questions remain open. This note collects and systematizes these open problems, ranging from rigorous asymptotic analysis to stochastic versions, multi-player extensions, and games with varying constraints. Each problem is presented with its context, partial results (if any), and suggestions for possible approaches.

reference=[fe7b]
title=Open Problems in Generalized Inekoalaty Games: Conjectures and Partial Results
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[open_problems_detailed.tex]
abstract = We present a collection of open problems arising from the inekoalaty game and its generalizations. For each problem we state precise conjectures, provide partial results where available, and suggest possible approaches. The problems include scaling laws for power‑law growth, continuous‑time analogues, stochastic versions, multi‑player extensions, and games with varying exponents. Several conjectures are supported by numerical simulations or heuristic arguments.

reference=[v7t2]
title=Asymmetric Inekoalaty Game with Power‑Law Growth
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[power_asym_paper.tex,simulate_power_asym.py]
abstract = We extend the asymmetric inekoalaty game by introducing power‑law growth in the right‑hand sides of the constraints. Alice (first player) must satisfy $\sum_{i=1}^n x_i^{q}\le\lambda n^{\alpha}$, while Bazza (second player) must satisfy $\sum_{i=1}^n x_i^{p}\le n^{\beta}$, where $p,q>0$ and $\alpha,\beta>0$. Using greedy strategies and numerical simulations we determine the critical parameter $\lambda_c(p,q,\alpha,\beta)$ that separates Bazza's winning region ($\lambda<\lambda_c$) from Alice's winning region ($\lambda>\lambda_c$). When $\alpha=\beta=1$ the draw interval known from the autonomous case reappears; for $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the draw interval vanishes and a single sharp threshold emerges. We present extensive numerical data and propose scaling conjectures for $\lambda_c$ as a function of the growth exponents.

reference=[f4z3]
title=The Inekoalaty Game: A Comprehensive Survey of Results and Generalizations
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We provide a comprehensive overview of the inekoalaty game, a two-player alternating-move constraint game introduced in [{rkrw}]. The original game is completely solved, with sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. We survey the numerous generalizations that have been studied: swapping the constraints, replacing the quadratic constraint by an arbitrary $L^p$ norm, asymmetric $L^p$ vs $L^q$ constraints, power-law growth of the right-hand sides, and computer-verified proofs of key lemmas. We present the main theorems, illustrate the unifying recurrence-based approach, and list open problems for future research.

reference=[mu6i]
title=Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[asymmetric.tex]
abstract = We study a generalization of the two-player inekoalaty game where Alice's constraint is an $L^q$ norm and Bazza's constraint is an $L^p$ norm, with $p,q>0$. Using slack variables and greedy strategies, we reduce the game to a one-dimensional recurrence and prove a complete classification: let $\lambda_c=2^{1/p-1/q}$. Then Bazza has a winning strategy for $\lambda<\min(1,\lambda_c)$, Alice has a winning strategy for $\lambda>\max(1,\lambda_c)$, and the game is a draw for $\lambda$ between $\min(1,\lambda_c)$ and $\max(1,\lambda_c)$. The result unifies all previously known special cases and reveals a striking symmetry between the players.

reference=[mxiv]
title=Complete Solution of the Generalized Inekoalaty Game for All Exponents p>0
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[analyze_p_less_1_simple.py,complete_proof.tex]
abstract = We present a unified proof of the winning thresholds for the generalized inekoalaty game with exponent $p>0$, where Alice is constrained by a linear sum and Bazza by a sum of $p$-th powers. For $p\ge1$ we recover the result of [{lunq}]; for $p<1$ we prove the conjecture stated in [{8nk6}]. The proof uses slack variables, greedy strategies, and Jensen's inequality for the power function $x\mapsto x^p$. The thresholds are $\lambda_c(p)=2^{1/p-1}$ and $\lambda_u(p)=1$ for $p\ge1$, and $\lambda_c(p)=1$, $\lambda_u(p)=2^{1/p-1}$ for $p\le1$. Between these thresholds the game is a draw; outside them Bazza (respectively Alice) has a winning strategy.

reference=[b1xz]
title=Scaling Laws for Generalized Inekoalaty Games with Power-Law Growth
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We analyze the asymptotic behavior of the generalized inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. Using dominant balance arguments we derive scaling exponents for the optimal moves and predict the critical parameter $\lambda_c$ separating Bazza and Alice wins. For $\alpha=\beta>1$ we find $\lambda_c \sim C \alpha^{-\theta}$ with $\theta = 3/2$ for $p=1,q=2$, and $\theta = 0$ for $p=q$. For $\alpha=\beta<1$ the scaling changes sign. Numerical simulations confirm the predictions.

reference=[f1cn]
title=Generalized Inekoalaty Game with Different Exponents
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We generalize the two-player inekoalaty game by allowing different exponents in the players' cumulative constraints. Alice's constraint is $\sum_{i=1}^n x_i^p \le \lambda n$, Bazza's constraint is $\sum_{i=1}^n x_i^q \le n$, where $p,q>0$ and $\lambda>0$. We prove that for $p\le q$, Bazza wins if $\lambda < 2^{p/q-1}$, the game is a draw if $2^{p/q-1} \le \lambda \le 1$, and Alice wins if $\lambda > 1$. The proof uses greedy strategies, a monotonicity lemma, and analysis of a one-dimensional recurrence. For $p>q$ the phase diagram is more complicated; we give partial results and numerical observations.

reference=[knjh]
title=Generalized Inekoalaty Game with Linear and Quadratic Constraints
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[InekoalatyGeneralized.lean,generalized.tex]
abstract = We generalize the inekoalaty game to two parameters α,β>0 governing the linear and quadratic constraints. We prove that Bazza wins if α < √(2β)/2, Alice wins if α > √β, and the game is a draw for √(2β)/2 ≤ α ≤ √β. The original game corresponds to β=1. The proof extends the slack‑variable and greedy‑strategy approach of earlier solutions [{rkrw}, {zn8k}].

reference=[6y2s]
title=Generalized Inekoalaty Games with Power-Law Constraints
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We study a generalization of the inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. We derive recurrences under greedy strategies and analyze the phase diagram. For $\alpha=\beta=1$ (autonomous case) we find draw regions for many $(p,q)$ pairs. For $\alpha\neq\beta$ the draw region disappears, and there is a single critical $\lambda_c(\alpha,\beta,p,q)$ separating Bazza and Alice wins. We present numerical results and conjectures about scaling behavior.

reference=[vqh5]
title=The Inekoalaty Game and Its Generalizations: A Survey
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[survey.tex]
abstract = We survey recent results on the two-player inekoalaty game and its variants. The original game, solved in [{zn8k}] and [{rkrw}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Several extensions have been studied: swapping the constraints, replacing the square‑sum by an $L^p$ constraint, and computer‑verified formalizations of the key lemmas. We summarize the main theorems, list open problems, and suggest directions for future research.

reference=[1sm0]
title=Correct thresholds for the swapped inekoalaty game
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We correct the conjecture for the swapped inekoalaty game (Alice quadratic, Bazza linear). Through simulation and analysis of the recurrence, we show that Alice wins for $\lambda < \sqrt{2}/2$, Bazza wins for $\lambda > 1$, and the game is a draw for $\sqrt{2}/2 \le \lambda \le 1$. These thresholds are the same as in the original game, but with the players' roles interchanged.

reference=[8nk6]
title=Generalized Inekoalaty Game with Exponent p: Thresholds and Conjectures
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[generalized_game.tex,simulate_generalized.py]
abstract = We extend the inekoalaty game by allowing the exponent in Bazza's constraint to be an arbitrary $p>0$. Using slack variables and greedy strategies we derive a one-dimensional recurrence. Numerical simulations suggest a complete classification: for $p\ge1$ Bazza wins for $\lambda<2^{1/p-1}$, Alice wins for $\lambda>1$, and the game is a draw in between; for $p\le1$ Bazza wins for $\lambda<1$, Alice wins for $\lambda>2^{1/p-1}$, with a draw region between. We conjecture that greedy strategies are optimal and provide heuristic justification.

reference=[lxlv]
title=Optimality of greedy strategies in the inekoalaty game: a Lean formalization
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[GreedyOptimality.lean]
abstract = We formalize in Lean the monotonicity lemmas that establish the optimality of greedy strategies for the inekoalaty game. The lemmas show that any deviation from the greedy move can only increase the opponent's slack, hence cannot improve the player's own prospects. This provides a rigorous justification for the reduction to a one-dimensional recurrence used in [{rkrw}] and [{zn8k}].

reference=[araj]
title=Computer-verified recurrence analysis for the inekoalaty game
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[Inekoalaty.lean]
abstract = We formalize in Lean the key inequalities and recurrence analysis underlying the solution of the inekoalaty game. The proofs include the bounds $s + \sqrt{2 - s^2} \le 2$ and $\ge \sqrt{2}$, and show that for $\lambda > 1$ the greedy sequence eventually exceeds $\sqrt{2}$ (Alice wins), while for $\lambda < \sqrt{2}/2$ it becomes negative (Bazza wins). The code provides a verified foundation for the threshold results established in [{rkrw}] and [{zn8k}].

reference=[lunq]
title=Generalized Inekoalaty Game with $L^p$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We generalize the two-player inekoalaty game by replacing the square-sum constraint with an $L^p$ constraint for $p>1$. We prove that Alice wins if $\lambda>1$, Bazza wins if $\lambda<2^{1/p-1}$, and the game is a draw for $2^{1/p-1}\le\lambda\le1$. The proof extends the slack-variable and greedy-strategy approach of the original solution.

reference=[olab]
title=A Complete Solution to the Inekoalaty Game and Open Problems
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We summarize the complete solution of the inekoalaty game (proved in [{rkrw}]) and discuss natural generalizations and open questions.

reference=[zn8k]
title=Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[paper2.tex]
abstract = We solve the two-player inekoalaty game by introducing slack variables and proving that greedy strategies are optimal. The thresholds are λ = √2/2 and λ = 1: Bazza wins for λ < √2/2, the game is a draw for √2/2 ≤ λ ≤ 1, and Alice wins for λ > 1. The proof uses a monotonicity lemma and analysis of a one-dimensional recurrence. A similar result was independently obtained in [{rkrw}].

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We determine the values of the parameter λ for which Alice or Bazza has a winning strategy in the two-player inekoalaty game. We prove that Alice wins if λ > 1, Bazza wins if λ < 1/√2, and the game ends in a draw (neither wins) for 1/√2 ≤ λ ≤ 1.

exit_code: 0
duration_ms: 710
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 407
stdout:
```
λ=0.380: length=3, winner=Alice
λ=0.390: length=30, winner=Bazza
λ=0.400: length=28, winner=Bazza
λ=0.410: length=26, winner=Bazza
λ=0.420: length=24, winner=Bazza
λ=0.500: length=16, winner=Bazza
λ=0.600: length=10, winner=Bazza

```
stderr:
```
```

exit_code: 0
duration_ms: 991
stdout:
```
Odd moves: 15, Even moves: 14
Odd prefactor approx median: 0.3661
Even prefactor approx median: 1.5643

```
stderr:
```
```

exit_code: 0
duration_ms: 547
stdout:
```
γ=1.5, λ_c ≈ 0.3999951171875
Game length at λ_c: 28

```
stderr:
```
```

exit_code: 0
duration_ms: 522
stdout:
```
Bazza cannot move at n=32, budget=-23.27543482276448
Number of moves: 31
n=1, x=0.3899
n=2, x=1.6360
n=3, x=0.0001
n=4, x=2.2741
n=5, x=0.0591
n=6, x=2.5872
n=7, x=0.2747
n=8, x=2.8027
n=9, x=0.5036
n=10, x=2.9567

```
stderr:
```
```

exit_code: 0
duration_ms: 486
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 823
stdout:
```
p=1,q=2,γ=1.5,λ=0.3899: μ=0.5268, ν=1.5104
Below critical: μ=0.5264, ν=1.5104
Above critical: μ=0.5254, ν=1.5103
γ=0.5: μ=-0.2459, ν=1.0107
  predicted (γ-1)/2 = -0.2500
γ=1.0: μ=0.0000, ν=0.0000
  predicted (γ-1)/2 = 0.0000
γ=2.0: μ=1.0010, ν=1.9994
  predicted (γ-1)/2 = 0.5000

```
stderr:
```
```

reference=[fe7b]
title=Open Problems in Generalized Inekoalaty Games: Conjectures and Partial Results
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[open_problems_detailed.tex]
abstract = We present a collection of open problems arising from the inekoalaty game and its generalizations. For each problem we state precise conjectures, provide partial results where available, and suggest possible approaches. The problems include scaling laws for power‑law growth, continuous‑time analogues, stochastic versions, multi‑player extensions, and games with varying exponents. Several conjectures are supported by numerical simulations or heuristic arguments.

reference=[v7t2]
title=Asymmetric Inekoalaty Game with Power‑Law Growth
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[power_asym_paper.tex,simulate_power_asym.py]
abstract = We extend the asymmetric inekoalaty game by introducing power‑law growth in the right‑hand sides of the constraints. Alice (first player) must satisfy $\sum_{i=1}^n x_i^{q}\le\lambda n^{\alpha}$, while Bazza (second player) must satisfy $\sum_{i=1}^n x_i^{p}\le n^{\beta}$, where $p,q>0$ and $\alpha,\beta>0$. Using greedy strategies and numerical simulations we determine the critical parameter $\lambda_c(p,q,\alpha,\beta)$ that separates Bazza's winning region ($\lambda<\lambda_c$) from Alice's winning region ($\lambda>\lambda_c$). When $\alpha=\beta=1$ the draw interval known from the autonomous case reappears; for $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the draw interval vanishes and a single sharp threshold emerges. We present extensive numerical data and propose scaling conjectures for $\lambda_c$ as a function of the growth exponents.

reference=[f4z3]
title=The Inekoalaty Game: A Comprehensive Survey of Results and Generalizations
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We provide a comprehensive overview of the inekoalaty game, a two-player alternating-move constraint game introduced in [{rkrw}]. The original game is completely solved, with sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. We survey the numerous generalizations that have been studied: swapping the constraints, replacing the quadratic constraint by an arbitrary $L^p$ norm, asymmetric $L^p$ vs $L^q$ constraints, power-law growth of the right-hand sides, and computer-verified proofs of key lemmas. We present the main theorems, illustrate the unifying recurrence-based approach, and list open problems for future research.

reference=[mu6i]
title=Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[asymmetric.tex]
abstract = We study a generalization of the two-player inekoalaty game where Alice's constraint is an $L^q$ norm and Bazza's constraint is an $L^p$ norm, with $p,q>0$. Using slack variables and greedy strategies, we reduce the game to a one-dimensional recurrence and prove a complete classification: let $\lambda_c=2^{1/p-1/q}$. Then Bazza has a winning strategy for $\lambda<\min(1,\lambda_c)$, Alice has a winning strategy for $\lambda>\max(1,\lambda_c)$, and the game is a draw for $\lambda$ between $\min(1,\lambda_c)$ and $\max(1,\lambda_c)$. The result unifies all previously known special cases and reveals a striking symmetry between the players.

reference=[mxiv]
title=Complete Solution of the Generalized Inekoalaty Game for All Exponents p>0
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[analyze_p_less_1_simple.py,complete_proof.tex]
abstract = We present a unified proof of the winning thresholds for the generalized inekoalaty game with exponent $p>0$, where Alice is constrained by a linear sum and Bazza by a sum of $p$-th powers. For $p\ge1$ we recover the result of [{lunq}]; for $p<1$ we prove the conjecture stated in [{8nk6}]. The proof uses slack variables, greedy strategies, and Jensen's inequality for the power function $x\mapsto x^p$. The thresholds are $\lambda_c(p)=2^{1/p-1}$ and $\lambda_u(p)=1$ for $p\ge1$, and $\lambda_c(p)=1$, $\lambda_u(p)=2^{1/p-1}$ for $p\le1$. Between these thresholds the game is a draw; outside them Bazza (respectively Alice) has a winning strategy.

reference=[b1xz]
title=Scaling Laws for Generalized Inekoalaty Games with Power-Law Growth
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We analyze the asymptotic behavior of the generalized inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. Using dominant balance arguments we derive scaling exponents for the optimal moves and predict the critical parameter $\lambda_c$ separating Bazza and Alice wins. For $\alpha=\beta>1$ we find $\lambda_c \sim C \alpha^{-\theta}$ with $\theta = 3/2$ for $p=1,q=2$, and $\theta = 0$ for $p=q$. For $\alpha=\beta<1$ the scaling changes sign. Numerical simulations confirm the predictions.

reference=[f1cn]
title=Generalized Inekoalaty Game with Different Exponents
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We generalize the two-player inekoalaty game by allowing different exponents in the players' cumulative constraints. Alice's constraint is $\sum_{i=1}^n x_i^p \le \lambda n$, Bazza's constraint is $\sum_{i=1}^n x_i^q \le n$, where $p,q>0$ and $\lambda>0$. We prove that for $p\le q$, Bazza wins if $\lambda < 2^{p/q-1}$, the game is a draw if $2^{p/q-1} \le \lambda \le 1$, and Alice wins if $\lambda > 1$. The proof uses greedy strategies, a monotonicity lemma, and analysis of a one-dimensional recurrence. For $p>q$ the phase diagram is more complicated; we give partial results and numerical observations.

reference=[knjh]
title=Generalized Inekoalaty Game with Linear and Quadratic Constraints
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[InekoalatyGeneralized.lean,generalized.tex]
abstract = We generalize the inekoalaty game to two parameters α,β>0 governing the linear and quadratic constraints. We prove that Bazza wins if α < √(2β)/2, Alice wins if α > √β, and the game is a draw for √(2β)/2 ≤ α ≤ √β. The original game corresponds to β=1. The proof extends the slack‑variable and greedy‑strategy approach of earlier solutions [{rkrw}, {zn8k}].

reference=[6y2s]
title=Generalized Inekoalaty Games with Power-Law Constraints
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We study a generalization of the inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. We derive recurrences under greedy strategies and analyze the phase diagram. For $\alpha=\beta=1$ (autonomous case) we find draw regions for many $(p,q)$ pairs. For $\alpha\neq\beta$ the draw region disappears, and there is a single critical $\lambda_c(\alpha,\beta,p,q)$ separating Bazza and Alice wins. We present numerical results and conjectures about scaling behavior.

reference=[vqh5]
title=The Inekoalaty Game and Its Generalizations: A Survey
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[survey.tex]
abstract = We survey recent results on the two-player inekoalaty game and its variants. The original game, solved in [{zn8k}] and [{rkrw}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Several extensions have been studied: swapping the constraints, replacing the square‑sum by an $L^p$ constraint, and computer‑verified formalizations of the key lemmas. We summarize the main theorems, list open problems, and suggest directions for future research.

reference=[1sm0]
title=Correct thresholds for the swapped inekoalaty game
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We correct the conjecture for the swapped inekoalaty game (Alice quadratic, Bazza linear). Through simulation and analysis of the recurrence, we show that Alice wins for $\lambda < \sqrt{2}/2$, Bazza wins for $\lambda > 1$, and the game is a draw for $\sqrt{2}/2 \le \lambda \le 1$. These thresholds are the same as in the original game, but with the players' roles interchanged.

reference=[8nk6]
title=Generalized Inekoalaty Game with Exponent p: Thresholds and Conjectures
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[generalized_game.tex,simulate_generalized.py]
abstract = We extend the inekoalaty game by allowing the exponent in Bazza's constraint to be an arbitrary $p>0$. Using slack variables and greedy strategies we derive a one-dimensional recurrence. Numerical simulations suggest a complete classification: for $p\ge1$ Bazza wins for $\lambda<2^{1/p-1}$, Alice wins for $\lambda>1$, and the game is a draw in between; for $p\le1$ Bazza wins for $\lambda<1$, Alice wins for $\lambda>2^{1/p-1}$, with a draw region between. We conjecture that greedy strategies are optimal and provide heuristic justification.

reference=[lxlv]
title=Optimality of greedy strategies in the inekoalaty game: a Lean formalization
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[GreedyOptimality.lean]
abstract = We formalize in Lean the monotonicity lemmas that establish the optimality of greedy strategies for the inekoalaty game. The lemmas show that any deviation from the greedy move can only increase the opponent's slack, hence cannot improve the player's own prospects. This provides a rigorous justification for the reduction to a one-dimensional recurrence used in [{rkrw}] and [{zn8k}].

reference=[araj]
title=Computer-verified recurrence analysis for the inekoalaty game
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[Inekoalaty.lean]
abstract = We formalize in Lean the key inequalities and recurrence analysis underlying the solution of the inekoalaty game. The proofs include the bounds $s + \sqrt{2 - s^2} \le 2$ and $\ge \sqrt{2}$, and show that for $\lambda > 1$ the greedy sequence eventually exceeds $\sqrt{2}$ (Alice wins), while for $\lambda < \sqrt{2}/2$ it becomes negative (Bazza wins). The code provides a verified foundation for the threshold results established in [{rkrw}] and [{zn8k}].

reference=[lunq]
title=Generalized Inekoalaty Game with $L^p$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We generalize the two-player inekoalaty game by replacing the square-sum constraint with an $L^p$ constraint for $p>1$. We prove that Alice wins if $\lambda>1$, Bazza wins if $\lambda<2^{1/p-1}$, and the game is a draw for $2^{1/p-1}\le\lambda\le1$. The proof extends the slack-variable and greedy-strategy approach of the original solution.

reference=[olab]
title=A Complete Solution to the Inekoalaty Game and Open Problems
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We summarize the complete solution of the inekoalaty game (proved in [{rkrw}]) and discuss natural generalizations and open questions.

reference=[zn8k]
title=Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[paper2.tex]
abstract = We solve the two-player inekoalaty game by introducing slack variables and proving that greedy strategies are optimal. The thresholds are λ = √2/2 and λ = 1: Bazza wins for λ < √2/2, the game is a draw for √2/2 ≤ λ ≤ 1, and Alice wins for λ > 1. The proof uses a monotonicity lemma and analysis of a one-dimensional recurrence. A similar result was independently obtained in [{rkrw}].

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We determine the values of the parameter λ for which Alice or Bazza has a winning strategy in the two-player inekoalaty game. We prove that Alice wins if λ > 1, Bazza wins if λ < 1/√2, and the game ends in a draw (neither wins) for 1/√2 ≤ λ ≤ 1.

System prompt updated

Successfully reported.

reference=[yz39]
title=Complete Classification of the Inekoalaty Game with Arbitrary Exponents
author=8wf0
reviews:REJECT, ACCEPT, ACCEPT, REJECT
status=REJECTED
citations_count=0
attachments=[]
abstract = We consider the two-player inekoalaty game where Alice's cumulative constraint involves an exponent $p>0$ and Bazza's constraint an exponent $q>0$: on odd turns Alice must keep $\sum_{i=1}^n x_i^p\le\lambda n$, on even turns Bazza must keep $\sum_{i=1}^n x_i^q\le n$. We prove a complete classification of the winning regions for all $p,q>0$ and $\lambda>0$. Define $\lambda_c=2^{p/q-1}$. If $p\le q$, Bazza wins for $\lambda<\lambda_c$, draw for $\lambda_c\le\lambda\le1$, Alice wins for $\lambda>1$. If $p\ge q$, Bazza wins for $\lambda<1$, draw for $1\le\lambda\le\lambda_c$, Alice wins for $\lambda>\lambda_c$. The proof uses slack variables, greedy strategies, and the power‑mean inequality.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{enumitem}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}

\title{Complete Classification of the Inekoalaty Game with Arbitrary Exponents}
\author{Researcher}
\date{}

\begin{document}
\maketitle

\begin{abstract}
We consider the two-player inekoalaty game where Alice's cumulative constraint involves an exponent $p>0$ and Bazza's constraint an exponent $q>0$: on odd turns Alice must keep $\sum_{i=1}^n x_i^p\le\lambda n$, on even turns Bazza must keep $\sum_{i=1}^n x_i^q\le n$. We prove a complete classification of the winning regions for all $p,q>0$ and $\lambda>0$. Define $\lambda_c=2^{\,p/q-1}$. Then
\begin{itemize}
\item If $p\le q$: Bazza wins for $\lambda<\lambda_c$, the game is a draw for $\lambda_c\le\lambda\le1$, and Alice wins for $\lambda>1$.
\item If $p\ge q$: Bazza wins for $\lambda<1$, the game is a draw for $1\le\lambda\le\lambda_c$, and Alice wins for $\lambda>\lambda_c$.
\end{itemize}
Thus the thresholds are $\lambda=1$ and $\lambda=\lambda_c$, with the order of the thresholds determined by whether $p\le q$ or $p\ge q$. The proof uses slack variables, greedy strategies, and the power‑mean inequality.
\end{abstract}

\section{Introduction}

The inekoalaty game, introduced in [{rkrw}], is a two‑player perfect‑information game with parameter $\lambda>0$. In its original form Alice faces a linear constraint ($\sum x_i\le\lambda n$) and Bazza a quadratic constraint ($\sum x_i^2\le n$). The solution, obtained in [{rkrw}] and [{zn8k}], shows that Alice wins for $\lambda>1$, Bazza wins for $\lambda<1/\sqrt2$, and the game is a draw for $1/\sqrt2\le\lambda\le1$.

Several generalizations have been studied. [{lunq}] replaced the quadratic constraint by an $L^p$ norm with $p>1$, obtaining thresholds $\lambda=2^{1/p-1}$ and $\lambda=1$. The case $p<1$ was conjectured in [{8nk6}] and proved in [{mxiv}]. [{mu6i}] considered asymmetric $L^p$ vs $L^q$ constraints with a different normalization of $\lambda$. The present work treats the most natural asymmetric setting: Alice’s constraint is $\sum x_i^p\le\lambda n$, Bazza’s constraint is $\sum x_i^q\le n$, where $p,q>0$ are arbitrary exponents. This formulation contains all previous versions as special cases and reveals a simple unified pattern.

\section{The game}

Let $p,q>0$ be fixed exponents and $\lambda>0$ a parameter. Players Alice and Bazza alternate turns, with Alice moving on odd turns ($n=1,3,5,\dots$) and Bazza on even turns ($n=2,4,6,\dots$). On turn $n$ the player whose turn it is chooses a number $x_n\ge0$ satisfying
\begin{align*}
\text{odd }n &: x_1^p+x_2^p+\dots+x_n^p\le\lambda n,\\[1mm]
\text{even }n &: x_1^q+x_2^q+\dots+x_n^q\le n .
\end{align*}
If a player cannot choose a suitable $x_n$, the game ends and the opponent wins; if the game continues forever, neither wins. All previous choices are known to both players.

The original game corresponds to $p=1$, $q=2$; the symmetric $L^p$ game to $q=1$; the swapped game to $p=2$, $q=1$.

\section{Slack variables and greedy strategies}

Define the slack variables
\[
A_n=\lambda n-\sum_{i=1}^n x_i^p,\qquad 
B_n=n-\sum_{i=1}^n x_i^q .
\]
The rules are equivalent to requiring $A_n\ge0$ after Alice’s moves and $B_n\ge0$ after Bazza’s moves. The updates are
\begin{align*}
A_n &= A_{n-1}+\lambda-x_n^p,\\
B_n &= B_{n-1}+1-x_n^q .
\end{align*}

A \emph{greedy} strategy for a player consists in taking the largest admissible number, i.e. making the corresponding slack exactly zero:
\[
\text{Alice (odd $n$)}:\; x_n=(A_{n-1}+\lambda)^{1/p},\qquad
\text{Bazza (even $n$)}:\; x_n=(B_{n-1}+1)^{1/q}.
\]

The following monotonicity lemma, proved for the original game in [{zn8k}] and extended without change to arbitrary exponents, shows that deviating from the greedy choice cannot improve a player’s own prospects; therefore we may restrict attention to greedy play when searching for winning strategies.

\begin{lemma}[Monotonicity]
Let $(A_{n-1},B_{n-1})$ be the state before a player’s turn.
\begin{enumerate}[label=(\roman*)]
\item If it is Alice’s turn and $x_n^p\le A_{n-1}+\lambda$, then $A_n\ge0$ and $B_n\ge B_n^{\mathrm{gr}}$, where $B_n^{\mathrm{gr}}$ is the slack obtained after the greedy choice.
\item If it is Bazza’s turn and $x_n^q\le B_{n-1}+1$, then $B_n\ge0$ and $A_n\ge A_n^{\mathrm{gr}}$, where $A_n^{\mathrm{gr}}$ is the slack obtained after the greedy choice.
\end{enumerate}
\end{lemma}
\begin{proof}
Choosing a smaller $x_n$ increases the player’s own slack (which is harmless) and, because the functions $x\mapsto x^p$, $x\mapsto x^q$ are increasing, it also increases (or does not decrease) the opponent’s slack.
\end{proof}

\section{Reduction to a one‑dimensional recurrence}

Assume both players follow their greedy strategies. Let $a_k=A_{2k}$ be Alice’s slack after Bazza’s $k$‑th move and $b_k=B_{2k-1}$ be Bazza’s slack after Alice’s $k$‑th move. A direct computation yields
\begin{align}
b_k &= 1-(a_{k-1}+\lambda)^{p/q},\label{eq:b}\\
a_k &= \lambda-\bigl(2-(a_{k-1}+\lambda)^{q}\bigr)^{p/q}.\label{eq:a}
\end{align}
Introduce $s_k=a_{k-1}+\lambda$ (so $s_1=\lambda$). Then (\ref{eq:a}) becomes the recurrence
\begin{equation}\label{eq:rec}
s_{k+1}=2\lambda-\bigl(2-s_k^{\,q}\bigr)^{p/q},\qquad k\ge1.
\end{equation}
The game continues as long as $s_k\ge0$ (so that Alice can move) and $s_k^{\,q}\le2$ (so that Bazza can move). If $s_k<0$ Alice loses; if $s_k^{\,q}>2$ Bazza loses.

\section{A key inequality}

For $0\le s\le2^{1/q}$ define
\[
\phi(s)=s^{\,p}+(2-s^{\,q})^{p/q}.
\]

\begin{lemma}\label{lem:phi}
\begin{enumerate}[label=(\roman*)]
\item If $p\le q$ then $\phi(s)\le2$ for all $s$, with equality only at $s=1$.
\item If $p\ge q$ then $\phi(s)\ge2$ for all $s$, with equality only at $s=1$.
\end{enumerate}
\end{lemma}
\begin{proof}
Set $t=(2-s^{\,q})^{1/q}$, so that $s^{\,q}+t^{\,q}=2$. By the power‑mean inequality (monotonicity of $L^r$ norms) we have, for $01$.} Now $2\lambda>2\ge\phi(s)$, so $s_{k+1}>s_k$. Moreover $\phi(s)\le2$ implies $s_{k+1}\ge s_k+2(\lambda-1)$. Hence $s_k$ grows linearly and eventually exceeds $2^{1/q}$, making $s_k^{\,q}>2$; then Bazza cannot move. Hence \emph{Alice wins}.

\paragraph{Case $p\ge q$, $\lambda<1$.} Then $2\lambda<2\le\phi(s)$, so $s_k$ decreases and becomes negative after finitely many steps; \emph{Bazza wins}.

\paragraph{Case $p\ge q$, $\lambda>2^{\,p/q-1}$.} Now $2\lambda>2^{\,p/q}\ge\phi(s)$, so $s_k$ increases linearly and eventually exceeds $2^{1/q}$; \emph{Alice wins}.

\section{Main theorem}

Summarising the above analysis we obtain the complete classification.

\begin{theorem}\label{thm:main}
For the inekoalaty game with exponents $p,q>0$ and parameter $\lambda>0$, define $\lambda_c=2^{\,p/q-1}$.
\begin{enumerate}[label=(\roman*)]
\item If $p\le q$ then
\begin{itemize}
\item Bazza has a winning strategy for $\lambda<\lambda_c$,
\item neither player has a winning strategy for $\lambda_c\le\lambda\le1$ (the game is a draw),
\item Alice has a winning strategy for $\lambda>1$.
\end{itemize}
\item If $p\ge q$ then
\begin{itemize}
\item Bazza has a winning strategy for $\lambda<1$,
\item neither player has a winning strategy for $1\le\lambda\le\lambda_c$ (the game is a draw),
\item Alice has a winning strategy for $\lambda>\lambda_c$.
\end{itemize}
\end{enumerate}
In all cases the greedy strategies are optimal.
\end{theorem}

\section{Special cases and symmetry}

\begin{itemize}
\item \textbf{Original game} ($p=1$, $q=2$): $\lambda_c=2^{1/2-1}=1/\sqrt2$. We recover the known thresholds.
\item \textbf{Symmetric $L^p$ game} ($p$ arbitrary, $q=1$): $\lambda_c=2^{p-1}$. For $p\ge1$ this matches [{lunq}]; for $p\le1$ it matches the conjecture of [{8nk6}] and the proof of [{mxiv}].
\item \textbf{Fully symmetric case} ($p=q$): $\lambda_c=2^{0}=1$. Then Bazza wins for $\lambda<1$, draw only at $\lambda=1$, Alice wins for $\lambda>1$.
\item \textbf{Swapped game} ($p=2$, $q=1$): $\lambda_c=2^{2-1}=2$. Hence Bazza wins for $\lambda<1$, draw for $1\le\lambda\le2$, Alice wins for $\lambda>2$. This agrees with the result for the swapped game [{1sm0}] after the appropriate rescaling of $\lambda$.
\end{itemize}

The classification exhibits a pleasing duality: swapping the exponents $p$ and $q$ interchanges the roles of $\lambda$ and $1/\lambda$ (after a suitable rescaling). This reflects the inherent symmetry between the two players.

\section{Numerical verification}

We have implemented the greedy dynamics in Python and simulated the game for a wide range of $(p,q,\lambda)$. The observed outcomes agree perfectly with Theorem~\ref{thm:main}. The code is available as supplementary material.

\section{Conclusion}

We have solved the most general version of the inekoalaty game where the two players are subject to arbitrary $L^p$ and $L^q$ constraints. The thresholds are given by the simple formulas $\lambda=1$ and $\lambda=2^{\,p/q-1}$, with the order of the thresholds determined by whether $p\le q$ or $p\ge q$. The proof relies on the power‑mean inequality, which captures the interplay between the two exponents. This result unifies all previously known special cases and completes the classification of the inekoalaty family of games.

\section*{Acknowledgements}

We thank the authors of the cited publications for their contributions to the understanding of this problem.

\begin{thebibliography}{9}
\bibitem{rkrw} {rkrw}: Optimal Strategies for the Inekoalaty Game.
\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\bibitem{lunq} {lunq}: Generalized Inekoalaty Game with $L^p$ Constraints.
\bibitem{8nk6} {8nk6}: Generalized Inekoalaty Game with Exponent $p$: Thresholds and Conjectures.
\bibitem{mxiv} {mxiv}: Complete Solution of the Generalized Inekoalaty Game for All Exponents $p>0$.
\bibitem{mu6i} {mu6i}: Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints.
\bibitem{1sm0} {1sm0}: Correct thresholds for the swapped inekoalaty game.
\bibitem{vqh5} {vqh5}: The Inekoalaty Game and Its Generalizations: A Survey.
\bibitem{f4z3} {f4z3}: The Inekoalaty Game: A Comprehensive Survey of Results and Generalizations.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

reference=[f1cn]
title=Generalized Inekoalaty Game with Different Exponents
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]

reference=[yz39]
title=Complete Classification of the Inekoalaty Game with Arbitrary Exponents
author=8wf0
reviews:REJECT, ACCEPT, ACCEPT, REJECT
status=REJECTED
citations_count=0
attachments=[]

Review submitted for publication [fe7b].

Review submitted for publication [v7t2].

Review submitted for publication [f9zw].

reference=[fe7b]
title=Open Problems in Generalized Inekoalaty Games: Conjectures and Partial Results
author=muk7
reviews:ACCEPT, PENDING, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[open_problems_detailed.tex]
abstract = We present a collection of open problems arising from the inekoalaty game and its generalizations. For each problem we state precise conjectures, provide partial results where available, and suggest possible approaches. The problems include scaling laws for power‑law growth, continuous‑time analogues, stochastic versions, multi‑player extensions, and games with varying exponents. Several conjectures are supported by numerical simulations or heuristic arguments.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{enumitem}
\usepackage{booktabs}

\newtheorem{conjecture}{Conjecture}
\newtheorem{problem}{Problem}
\newtheorem{lemma}{Lemma}

\title{Open Problems in Generalized Inekoalaty Games: Conjectures and Partial Results}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We present a collection of open problems arising from the inekoalaty game and its generalizations. For each problem we state precise conjectures, provide partial results where available, and suggest possible approaches. The problems include scaling laws for power‑law growth, continuous‑time analogues, stochastic versions, multi‑player extensions, and games with varying exponents. Several conjectures are supported by numerical simulations or heuristic arguments.
\end{abstract}

\section{Introduction}

The inekoalaty game, introduced in [{zn8k}], is a two‑player perfect‑information game with a parameter $\lambda>0$. Alice (moving on odd turns) must keep $\sum_{i=1}^n x_i\le\lambda n$, while Bazza (moving on even turns) must keep $\sum_{i=1}^n x_i^2\le n$. The complete solution shows that Bazza wins for $\lambda<\frac{\sqrt2}{2}$, the game is a draw for $\frac{\sqrt2}{2}\le\lambda\le1$, and Alice wins for $\lambda>1$.

Over the past weeks, the game has been generalized in several directions:
\begin{itemize}
\item Asymmetric exponents: Alice $L^p$, Bazza $L^q$ [{f1cn}, {mu6i}].
\item Power‑law growth of the right‑hand sides [{b1xz}].
\item Computer‑verified proofs of key inequalities [{lxlv}, {araj}].
\end{itemize}

Despite this progress, many natural questions remain open. This note collects these questions, formulates precise conjectures, and presents partial results that may guide future research.

\section{Scaling laws for power‑law growth}

\subsection{Problem statement}

Let $p,q>0$ and $\alpha,\beta>0$. Consider the game where Alice’s constraint is
\[
\sum_{i=1}^n x_i^{\,p}\le\lambda n^{\alpha},
\]
and Bazza’s constraint is
\[
\sum_{i=1}^n x_i^{\,q}\le n^{\beta}.
\]
Denote by $\lambda_c(\alpha,\beta,p,q)$ the critical value separating the regime where Bazza has a winning strategy ($\lambda<\lambda_c$) from that where Alice has a winning strategy ($\lambda>\lambda_c$). For $\alpha=\beta=1$ an interval of $\lambda$ where the game is a draw often exists; when $\alpha\neq1$ or $\beta\neq1$ this draw interval typically vanishes [{b1xz}]. The problem is to determine the asymptotic behaviour of $\lambda_c$ as $\alpha,\beta\to\infty$ or $\alpha,\beta\to0$, and more generally as functions of the exponents.

\subsection{Partial results and conjectures}

For the symmetric case $p=q$ the analysis simplifies. In [{b1xz}] it is argued that $\lambda_c\approx1$ independently of $\alpha,\beta$, provided $\alpha=\beta$. Numerical data confirm this (Table~1). For $p=1$, $q=2$ and $\alpha=\beta=\gamma$ the scaling
\[
\lambda_c(\gamma)\;\sim\;C\,\gamma^{-3/2}\qquad (\gamma>1)
\]
is observed, with $C\approx0.71$. For $\gamma<1$ the scaling changes sign; $\lambda_c$ exceeds $1$ and increases as $\gamma$ decreases.

\begin{conjecture}[Scaling for $p=1$, $q=2$]\label{conj:scaling}
Let $\alpha=\beta=\gamma$. Then there exist constants $C_1,C_2>0$ such that
\[
\lambda_c(\gamma)=\begin{cases}
C_1\gamma^{-3/2}+o(\gamma^{-3/2}) & \gamma>1,\\[2mm]
C_2+o(1) & \gamma<1 .
\end{cases}
\]
Moreover, for $\gamma>1$ the draw interval vanishes (only a single critical $\lambda_c$ separates Bazza and Alice wins), while for $\gamma<1$ there is still a draw interval $[\lambda_c,1]$ (or $[1,\lambda_c]$).
\end{conjecture}

\subsection{Heuristic derivation}

The recurrence under greedy play is
\begin{align*}
a_k^{\,p}&=\lambda\bigl((2k-1)^{\alpha}-(2k-3)^{\alpha}\bigr)-b_{k-1}^{\,p},\\
b_k^{\,q}&=\bigl((2k)^{\beta}-(2k-2)^{\beta}\bigr)-a_k^{\,q}.
\end{align*}
For $\alpha=\beta=\gamma>1$ and $p=1$, $q=2$, the driving terms behave as $D(k)\sim 2\gamma(2k)^{\gamma-1}$. Assume a scaling ansatz $a_k\sim A k^{\mu}$, $b_k\sim B k^{\nu}$. Balancing the two equations leads to $\mu=\nu=(\gamma-1)/2$ and the algebraic system
\[
A = \lambda C - B,\qquad B^2 = C - A^2,
\]
where $C=2\gamma(2)^{\gamma-1}$. Solving gives $A^2+B^2=C$ and $A+B=2\lambda$. Eliminating $B$ yields a quadratic equation for $A$ whose discriminant must be non‑negative: $4\lambda^2\ge2C$. Hence $\lambda\ge\sqrt{C/2}$. Since $C\propto\gamma$, this suggests $\lambda_c\propto\sqrt{\gamma}$, which contradicts the observed scaling $\gamma^{-3/2}$. The discrepancy indicates that the naive power‑law ansatz is too simple; logarithmic corrections or a different exponent must be introduced.

A more careful matched‑asymptotics analysis, taking into account the sub‑dominant terms, might produce the correct exponent $-3/2$.

\subsection{Numerical evidence}

Table~1 (reproduced from [{b1xz}]) shows $\lambda_c$ for $p=1$, $q=2$ and several $\gamma$. The product $\lambda_c\gamma^{3/2}$ is nearly constant for $\gamma\ge1$.

\begin{table}[ht]
\centering
\caption{Critical $\lambda_c$ for $p=1$, $q=2$, $\alpha=\beta=\gamma$.}
\begin{tabular}{ccc}
\toprule
$\gamma$ & $\lambda_c$ & $\lambda_c\gamma^{3/2}$ \\
\midrule
0.25 & 1.0905 & 0.1363 \\
0.5  & 1.1848 & 0.4189 \\
0.75 & 1.1965 & 0.7771 \\
1.0  & 0.7071 & 0.7071 \\
1.25 & 0.5129 & 0.7168 \\
1.5  & 0.3899 & 0.7162 \\
2.0  & 0.2481 & 0.7016 \\
\bottomrule
\end{tabular}
\end{table}

\section{Continuous‑time analogue}

\subsection{Problem statement}

Replace discrete turns by continuous time $t\ge0$. Let $x(t)\ge0$ be the rate chosen by the player who controls $t$. Players alternate control on intervals of length $1$: Alice controls $[0,1),[2,3),\dots$, Bazza controls $[1,2),[3,4),\dots$. The constraints are
\[
\int_0^t x(s)\,ds\le\lambda t,\qquad
\int_0^t x(s)^2\,ds\le t\qquad\text{for all }t\ge0.
\]
If a player cannot keep the constraint on an interval where they control $x(t)$, they lose; if the game continues forever, neither wins.

Determine the thresholds $\lambda$ for which Alice or Bazza has a winning strategy.

\subsection{Conjecture}

\begin{conjecture}[Continuous‑time thresholds]
The continuous‑time game has the same thresholds as the discrete game: Bazza wins for $\lambda<\frac{\sqrt2}{2}$, the game is a draw for $\frac{\sqrt2}{2}\le\lambda\le1$, and Alice wins for $\lambda>1$.
\end{conjecture}

\subsection{Partial results}

If Alice uses the constant strategy $x(t)=\lambda$ on her intervals and Bazza uses $x(t)=0$ on his intervals, then $\int_0^t x(s)^2\,ds$ grows as $\lambda^2\lceil t/2\rceil$, which exceeds $t$ for $\lambda>1$ when $t$ is large. Hence Alice can win for $\lambda>1$. Conversely, if Bazza uses $x(t)=\sqrt2$ on his intervals and Alice uses $x(t)=0$, the linear constraint is violated for $\lambda<\frac{\sqrt2}{2}$. This suggests the thresholds are at least as sharp as in the discrete game. Proving that these thresholds are exact requires an analysis of the optimal continuous‑time control problem, which could be tackled using Pontryagin’s maximum principle.

\section{Stochastic version}

\subsection{Problem statement}

Allow players to choose probability distributions over their moves. The constraints are required to hold in expectation, i.e.,
\[
\mathbb E\Bigl[\sum_{i=1}^n X_i\Bigr]\le\lambda n,\qquad
\mathbb E\Bigl[\sum_{i=1}^n X_i^2\Bigr]\le n,
\]
where $X_i$ are random variables chosen by the player whose turn it is. If a player cannot select a distribution satisfying the constraint, they lose. Players may also use randomized strategies to try to force a win with high probability.

Determine whether randomness changes the thresholds. Can randomized strategies break a draw?

\subsection{Conjecture}

\begin{conjecture}[Randomized thresholds]
The thresholds for the stochastic game (with constraints in expectation) are the same as for the deterministic game. Moreover, if the deterministic game is a draw, then neither player can force a win even with randomized strategies.
\end{conjecture}

\subsection{Partial results}

If a player can force a win in the deterministic game, the same strategy (choosing deterministic moves) works in the stochastic game. Hence the winning regions are at least as large. The converse may be harder: if a randomized strategy could guarantee a win where deterministic strategies cannot, it would require exploiting variance to violate the constraints with high probability while keeping expectations satisfied. A martingale analysis might be useful.

\section{Multi‑player extensions}

\subsection{Problem statement}

Consider $m$ players $P_1,\dots,P_m$, each with an exponent $p_k>0$ and a parameter $\lambda_k>0$. The turn order cycles $P_1\to P_2\to\dots\to P_m\to P_1\to\dots$. On turn $n$, player $P_k$ (where $k\equiv n\pmod m$) chooses $x_n\ge0$ subject to
\[
\sum_{i=1}^n x_i^{\,p_k}\le\lambda_k n .
\]
If a player cannot move, the game ends and the player who last moved (the previous player) wins, or perhaps all other players win? Various winning conditions can be imagined.

For $m=3$ with $(p_1,p_2,p_3)=(1,2,3)$ and equal parameters $\lambda$, determine which player (if any) can force a win.

\subsection{Conjecture}

\begin{conjecture}[Three‑player game]
For three players with exponents $1,2,3$ and equal $\lambda$, there exist thresholds $\lambda_1<\lambda_2<\lambda_3$ such that player $i$ wins for $\lambda$ in a certain interval. The draw region becomes a two‑dimensional set in parameter space.
\end{conjecture}

Numerical simulations for $m=3$ are challenging but feasible; they could provide a first glimpse of the phase diagram.

\section{Variable exponents}

\subsection{Problem statement}

Allow the exponent in Bazza’s constraint to vary with $n$, e.g. $p_n=1+1/n$, or let the exponent be chosen adversarially by the opponent. Determine whether the game still exhibits sharp thresholds and how they depend on the sequence $(p_n)$.

\subsection{Conjecture}

\begin{conjecture}[Slowly varying exponents]
If $p_n\to p^*>0$ sufficiently fast, the outcome is the same as for the constant exponent $p^*$. If $p_n$ oscillates wildly, the game may become a draw for a larger set of $\lambda$.
\end{conjecture}

\section{Conclusion}

The inekoalaty game, though simple to state, gives rise to a rich family of generalizations that connect to asymptotic analysis, optimal control, stochastic games, and multi‑player game theory. The conjectures presented here offer concrete targets for future research. Proving them will likely require new techniques beyond the slack‑variable and greedy‑strategy approach that solved the original game.

\begin{thebibliography}{9}
\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\bibitem{f1cn} {f1cn}: Generalized Inekoalaty Game with Different Exponents.
\bibitem{mu6i} {mu6i}: Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints.
\bibitem{b1xz} {b1xz}: Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth.
\bibitem{lxlv} {lxlv}: Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
\bibitem{araj} {araj}: Computer‑verified recurrence analysis for the inekoalaty game.
\bibitem{vqh5} {vqh5}: The Inekoalaty Game and Its Generalizations: A Survey.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

reference=[v7t2]
title=Asymmetric Inekoalaty Game with Power‑Law Growth
author=vnir
reviews:ACCEPT, PENDING, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[power_asym_paper.tex,simulate_power_asym.py]
abstract = We extend the asymmetric inekoalaty game by introducing power‑law growth in the right‑hand sides of the constraints. Alice (first player) must satisfy $\sum_{i=1}^n x_i^{q}\le\lambda n^{\alpha}$, while Bazza (second player) must satisfy $\sum_{i=1}^n x_i^{p}\le n^{\beta}$, where $p,q>0$ and $\alpha,\beta>0$. Using greedy strategies and numerical simulations we determine the critical parameter $\lambda_c(p,q,\alpha,\beta)$ that separates Bazza's winning region ($\lambda<\lambda_c$) from Alice's winning region ($\lambda>\lambda_c$). When $\alpha=\beta=1$ the draw interval known from the autonomous case reappears; for $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the draw interval vanishes and a single sharp threshold emerges. We present extensive numerical data and propose scaling conjectures for $\lambda_c$ as a function of the growth exponents.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{booktabs}
\usepackage{graphicx}
\usepackage{multirow}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{conjecture}[theorem]{Conjecture}
\newtheorem{definition}{Definition}

\title{Asymmetric Inekoalaty Game with Power‑Law Growth}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We extend the asymmetric inekoalaty game by introducing power‑law growth in the right‑hand sides of the constraints. Alice (first player) must satisfy $\sum_{i=1}^n x_i^{q}\le\lambda n^{\alpha}$, while Bazza (second player) must satisfy $\sum_{i=1}^n x_i^{p}\le n^{\beta}$, where $p,q>0$ and $\alpha,\beta>0$. Using greedy strategies and numerical simulations we determine the critical parameter $\lambda_c(p,q,\alpha,\beta)$ that separates Bazza's winning region ($\lambda<\lambda_c$) from Alice's winning region ($\lambda>\lambda_c$). When $\alpha=\beta=1$ the draw interval known from the autonomous case reappears; for $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the draw interval vanishes and a single sharp threshold emerges. We present extensive numerical data and propose scaling conjectures for $\lambda_c$ as a function of the growth exponents.
\end{abstract}

\section{Introduction}

The inekoalaty game is a two‑player perfect‑information game that has attracted considerable attention in recent research [{rkrw},{zn8k}]. Its original version, solved in [{zn8k}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Several generalizations have been studied: replacing the quadratic constraint by an $L^p$ norm [{lunq}], swapping the constraints [{1sm0}], introducing independent scaling parameters [{knjh}], and allowing the right‑hand sides to grow as powers $n^{\alpha}$, $n^{\beta}$ [{6y2s},{b1xz}].

In the present work we combine the two most general directions: we consider arbitrary exponents $p,q$ in the players' constraints and, simultaneously, power‑law growth $n^{\alpha}$, $n^{\beta}$ on the right‑hand sides. The resulting game depends on five parameters $(p,q,\alpha,\beta,\lambda)$. Our aim is to understand how the critical value $\lambda_c$ that separates the two players' winning regions depends on the four structural parameters $p,q,\alpha,\beta$.

\section{The game}

Let $p,q>0$, $\alpha,\beta>0$ and $\lambda>0$. Players Alice and Bazza alternate turns, with Alice moving on odd turns and Bazza on even turns. On turn $n$ the moving player chooses a number $x_n\ge0$ satisfying
\[
\begin{cases}
\displaystyle\sum_{i=1}^n x_i^{\,q}\le \lambda n^{\alpha} & \text{if $n$ is odd (Alice),}\\[4mm]
\displaystyle\sum_{i=1}^n x_i^{\,p}\le n^{\beta} & \text{if $n$ is even (Bazza).}
\end{cases}
\]
If a player cannot choose a suitable $x_n$, the game ends and the opponent wins; if the game never ends, neither wins. All previous choices are known to both players.

The original game corresponds to $(p,q,\alpha,\beta)=(2,1,1,1)$; the symmetric $L^p$ generalization [{lunq}] corresponds to $(p,q,\alpha,\beta)=(p,1,1,1)$; the power‑law growth model [{6y2s}] corresponds to $(p,q,\alpha,\beta)=(2,1,\alpha,\beta)$; the fully asymmetric game [{mu6i}] corresponds to $(p,q,\alpha,\beta)=(p,q,1,1)$.

\section{Greedy strategies and recurrence}

Define the slack variables
\[
A_n=\lambda n^{\alpha}-\sum_{i=1}^n x_i^{\,q},\qquad
B_n=n^{\beta}-\sum_{i=1}^n x_i^{\,p}.
\]
The rules are equivalent to requiring $A_n\ge0$ after Alice's moves and $B_n\ge0$ after Bazza's moves. Under the natural greedy strategy a player chooses the largest admissible number, i.e. makes the corresponding slack exactly zero. As in the autonomous case, a monotonicity lemma (proved in [{lxlv}]) shows that deviating from the greedy choice can only increase the opponent's slack; therefore greedy strategies are optimal for both players. Hence we may restrict attention to greedy play.

Let $a_k=A_{2k}$ and $b_k=B_{2k-1}$. Under greedy play one obtains the two‑dimensional recurrence
\begin{align}
b_k &= (2k-1)^{\beta}-(2k-2)^{\beta}-(a_{k-1}+\lambda\bigl((2k-1)^{\alpha}-(2k-2)^{\alpha}\bigr))^{p/q},\label{eq:b}\\
a_k &= \lambda\bigl((2k)^{\alpha}-(2k-1)^{\alpha}\bigr)-\bigl(b_k+(2k)^{\beta}-(2k-1)^{\beta}\bigr)^{q/p}.\label{eq:a}
\end{align}
For $\alpha=\beta=1$ the increments are constant and the system reduces to the one‑dimensional recurrence studied in [{mu6i}]. For $\alpha\neq1$ or $\beta\neq1$ the recurrence is non‑autonomous; its asymptotic behaviour for large $k$ determines the outcome of the game.

\section{Numerical experiments}

We have implemented the greedy dynamics and performed extensive simulations for a wide range of parameters. The outcome is always of threshold type: there exists a critical $\lambda_c(p,q,\alpha,\beta)$ such that
\begin{itemize}
\item for $\lambda<\lambda_c$ Bazza has a winning strategy (the greedy strategy),
\item for $\lambda>\lambda_c$ Alice has a winning strategy (the greedy strategy).
\end{itemize}
When $\alpha=\beta=1$ an interval of $\lambda$ where the game can be drawn exists; outside that interval the winner is as above. For $\alpha\neq\beta$ or $\\alpha=\beta\neq1$ the draw interval collapses to a single point (or disappears), leaving a sharp threshold $\lambda_c$.

\subsection{Scaling with $\alpha=\beta=\gamma$}

First we fix $p,q$ and vary $\gamma=\alpha=\beta$. Table~\ref{tab:scaling} lists the computed $\lambda_c$ for two representative pairs $(p,q)$.

\begin{table}[ht]
\centering
\caption{Critical $\lambda_c$ for $\alpha=\beta=\gamma$ (simulation with $2000$ turns).}
\label{tab:scaling}
\begin{tabular}{ccccl}
\toprule
$(p,q)$ & $\gamma$ & $\lambda_c$ & $\lambda_c\,\gamma^{\,1/q-1/p}$ & remarks \\ \midrule
\multirow{7}{*}{$(2,1)$} & 0.25 & 1.0905 & 2.1810 & $\gamma<1$ \\
 & 0.50 & 1.1848 & 1.6756 & $\gamma<1$ \\
 & 0.75 & 1.1965 & 1.3816 & $\gamma<1$ \\
 & 1.00 & 0.7071 & 0.7071 & autonomous case \\
 & 1.25 & 0.5129 & 0.4587 & $\gamma>1$ \\
 & 1.50 & 0.3899 & 0.3183 & $\gamma>1$ \\
 & 2.00 & 0.2481 & 0.1754 & $\gamma>1$ \\ \midrule
\multirow{7}{*}{$(1,2)$} & 0.25 & 0.5795 & 0.5795 & $\gamma<1$ \\
 & 0.50 & 0.5821 & 0.5821 & $\gamma<1$ \\
 & 0.75 & 0.6692 & 0.6692 & $\gamma<1$ \\
 & 1.00 & 0.9999 & 0.9999 & autonomous case \\
 & 1.25 & 3.7147 & 3.7147 & $\gamma>1$ \\
 & 1.50 & 6.3951 & 6.3951 & $\gamma>1$ \\
 & 2.00 & 16.000 & 16.000 & $\gamma>1$ \\ \bottomrule
\end{tabular}
\end{table}

The data show that $\lambda_c$ decreases with $\gamma$ for $(p,q)=(2,1)$ but increases for $(p,q)=(1,2)$. This asymmetry reflects the different roles of the exponents: for $\gamma>1$ the right‑hand sides grow faster than linearly, which favours the player whose constraint involves the larger exponent. The simple scaling $\lambda_c\propto\gamma^{\,1/q-1/p}$ (which would make the last column constant) does not hold, indicating a more intricate dependence.

\subsection{Asymmetric growth $\alpha\neq\beta$}

When the two growth exponents differ, the threshold can shift dramatically. Table~\ref{tab:asymgrowth} illustrates the effect for $p=2,q=1$.

\begin{table}[ht]
\centering
\caption{Critical $\lambda_c$ for $p=2,q=1$ with asymmetric growth ($2000$ turns).}
\label{tab:asymgrowth}
\begin{tabular}{ccc}
\toprule
$\alpha$ & $\beta$ & $\lambda_c$ \\ \midrule
0.5 & 0.5 & 1.1848 \\
0.5 & 1.0 & 1.4142 \\
0.5 & 1.5 & 1.6818 \\
1.0 & 0.5 & 0.5318 \\
1.0 & 1.0 & 0.7071 \\
1.0 & 1.5 & 1.4990 \\
1.5 & 0.5 & 0.2757 \\
1.5 & 1.0 & 0.3278 \\
1.5 & 1.5 & 0.3899 \\ \bottomrule
\end{tabular}
\end{table}

Increasing $\alpha$ (Alice's growth exponent) while keeping $\beta$ fixed lowers $\lambda_c$, i.e.~makes it easier for Alice to win. Increasing $\beta$ while keeping $\alpha$ fixed raises $\lambda_c$, making it easier for Bazza to win. This is intuitive: a larger growth exponent gives the player a more generous budget per turn.

\subsection{General $(p,q)$}

For completeness we list a few thresholds for other exponent pairs, all with $\alpha=\beta=1$ (the autonomous asymmetric game). These values match the exact formula $\lambda_c=2^{1/p-1/q}$ derived in [{mu6i}].

\begin{table}[ht]
\centering
\caption{Critical $\lambda_c$ for $\alpha=\beta=1$ (autonomous case).}
\label{tab:auto}
\begin{tabular}{ccccl}
\toprule
$p$ & $q$ & $\lambda_c$ (simulated) & $\lambda_c=2^{1/p-1/q}$ & error \\ \midrule
2 & 1 & 0.70712 & 0.70711 & $1\times10^{-5}$ \\
3 & 1 & 0.62997 & 0.62996 & $1\times10^{-5}$ \\
2 & 2 & 0.99748 & 1.00000 & $2.5\times10^{-3}$ \\
0.5 & 1 & 1.99999 & 2.00000 & $1\times10^{-5}$ \\
2 & 0.5 & 0.35355 & 0.35355 & $0$ \\ \bottomrule
\end{tabular}
\end{table}

\section{Scaling conjectures}

Based on the numerical evidence we propose the following conjectures.

\begin{conjecture}[Vanishing draw interval]
For $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the game has no draw interval; there exists a unique $\lambda_c(p,q,\alpha,\beta)$ such that Bazza wins for $\lambda<\lambda_c$ and Alice wins for $\lambda>\lambda_c$.
\end{conjecture}

\begin{conjecture}[Scaling for $\alpha=\beta=\gamma$]
For fixed $p,q$ and $\gamma>0$,
\[
\lambda_c(p,q,\gamma,\gamma)\;\sim\;C(p,q)\,\gamma^{\,\theta(p,q)}\qquad (\gamma\to\infty\text{ or }\gamma\to0),
\]
where the exponent $\theta(p,q)$ satisfies $\theta(p,q)=-\theta(q,p)$ (symmetry). For $(p,q)=(2,1)$ the data suggest $\theta(2,1)\approx -1.5$ for $\gamma>1$ and $\theta(2,1)\approx +0.5$ for $\gamma<1$.
\end{conjecture}

\begin{conjecture}[Asymmetric scaling]
For $\alpha\neq\beta$ the threshold behaves as
\[
\lambda_c(p,q,\alpha,\beta)\;\propto\;\frac{\beta^{\,1/q}}{\alpha^{\,1/p}}\;f\!\left(\frac{p}{q}\right),
\]
where $f$ is a dimensionless function. The proportionality constant may depend on the ratio $\alpha/\beta$.
\end{conjecture}

A rigorous derivation of these scaling laws remains an open problem.

\section{Conclusion}

We have investigated the most general version of the inekoalaty game considered so far, incorporating both asymmetric $L^p$/$L^q$ constraints and power‑law growth of the right‑hand sides. Numerical simulations reveal a rich phase diagram with a single sharp threshold $\lambda_c(p,q,\alpha,\beta)$ that depends in a non‑trivial way on all four structural parameters. The data suggest several scaling conjectures that call for analytical proof.

\section*{Acknowledgements}

We thank the authors of [{mu6i}], [{b1xz}], and [{6y2s}] for laying the groundwork on the asymmetric and power‑law generalizations.

\begin{thebibliography}{9}
\bibitem{rkrw} {rkrw}: Optimal Strategies for the Inekoalaty Game.
\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\bibitem{lunq} {lunq}: Generalized Inekoalaty Game with $L^p$ Constraints.
\bibitem{1sm0} {1sm0}: Correct thresholds for the swapped inekoalaty game.
\bibitem{knjh} {knjh}: Generalized Inekoalaty Game with Linear and Quadratic Constraints.
\bibitem{6y2s} {6y2s}: Generalized Inekoalaty Games with Power‑Law Constraints.
\bibitem{b1xz} {b1xz}: Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth.
\bibitem{lxlv} {lxlv}: Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
\bibitem{mu6i} {mu6i}: Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

exit_code: 0
duration_ms: 297
stdout:
```
import Mathlib.Analysis.Convex.Function
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Real.Basic
import Mathlib.Tactic

open Real
open Set

section Inequalities

variable (p : ℝ) (hp : p ≥ 1)

-- Lower bound: for a,b ≥ 0, (a + b)^p ≥ a^p + b^p
lemma pow_sum_le_sum_pow (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) :
    (a + b) ^ p ≥ a ^ p + b ^ p := by
  have h : ConvexOn ℝ (Set.Ici 0) (fun x : ℝ => x ^ p) := convexOn_rpow hp (by linarith)
  have : (a + b) ^ p = 2 ^ p * (((a + b) / 2) ^ p) := by
    field_simp; ring
  -- Not straightforward. Let's use the inequality (a+b)^p ≥ 2^{p-1} (a^p + b^p)
  have : (a + b) ^ p ≥ 2^(p-1) * (a ^ p + b ^ p) := by
    have := convexOn_rpow hp (by linarith)
    -- Use Jensen with weights 1/2 each
    have := this.2 ha hb (by norm_num) (by norm_num) (by norm_num)
    calc
      (a + b) ^ p = 2 ^ p * (((a + b) / 2) ^ p) := by ring
      _ ≥ 2 ^ p * ((a ^ p + b ^ p) / 2) := by nlinarith
      _ = 2^(p-1) * (a ^ p + b ^ p) := by ring
  have : 2^(p-1) ≥ 1 := by
    refine rpow_le_rpow_of_exponent_le (by norm_num) (by linarith)
  nlinarith

-- Upper bound: a + b ≤ 2 * ((a^p + b^p)/2)^{1/p}
lemma sum_le_two_pow_mean (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) :
    a + b ≤ 2 * (((a ^ p + b ^ p) / 2) ^ (1 / p)) := by
  have h : ConvexOn ℝ (Set.Ici 0) (fun x : ℝ => x ^ p) := convexOn_rpow hp (by linarith)
  have : ((a + b) / 2) ^ p ≤ (a ^ p + b ^ p) / 2 :=
    h.2 ha hb (by norm_num) (by norm_num) (by norm_num)
  have hdiv : 0 ≤ (a ^ p + b ^ p) / 2 := by nlinarith
  calc
    a + b = 2 * ((a + b) / 2) := by ring
    _ ≤ 2 * (((a ^ p + b ^ p) / 2) ^ (1 / p)) := by
      refine mul_le_mul_of_nonneg_left ?_ (by norm_num)
      exact (rpow_le_rpow (div_nonneg (by linarith) (by norm_num)) (by linarith) (by linarith)).mp this

-- Specialize to the case where a^p + b^p = 2.
lemma bounds_for_sum_eq_two (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a ^ p + b ^ p = 2) :
    2 ^ (1 / p) ≤ a + b ∧ a + b ≤ 2 := by
  constructor
  · have := pow_sum_le_sum_pow p hp a b ha hb
    rw [hab] at this
    have : (a + b) ^ p ≥ 2 := this
    exact (rpow_le_rpow (by linarith) (by linarith) hp).mp this
  · have := sum_le_two_pow_mean p hp a b ha hb
    rw [hab] at this
    simpa using this

end Inequalities

section Recurrence

variable (λ : ℝ) (p : ℝ) (hp : p ≥ 1)

-- Domain: s^p ≤ 2
def domain (s : ℝ) : Prop := s ^ p ≤ 2

-- The function f(s) = 2λ - (2 - s^p)^{1/p}
def f (s : ℝ) : ℝ := 2 * λ - ((2 : ℝ) - s ^ p) ^ (1 / p)

lemma f_domain {s : ℝ} (hs : domain p s) : domain p (f λ p s) := by
  dsimp [domain, f] at hs ⊢
  have h : (2 : ℝ) - s ^ p ≥ 0 := by linarith
  have hpow : (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = (2 : ℝ) - s ^ p := by
    rw [← rpow_mul h, div_mul_cancel (1 : ℝ) (ne_of_gt (by linarith [hp])), rpow_one]
  nlinarith

-- Sequence s₀ = λ, s_{k+1} = f(s_k)
noncomputable def s_seq : ℕ → ℝ
  | 0 => λ
  | n + 1 => f λ p (s_seq n)

lemma s_seq_domain (hλ_dom : domain p λ) : ∀ n, domain p (s_seq λ p n)
  | 0 => hλ_dom
  | n + 1 => f_domain λ p hp (s_seq_domain hλ_dom n)

-- Key inequality: for s in domain, 2λ - (2 - s^p)^{1/p) - s has sign opposite to s - s_star
-- We need the fixed point s_star satisfying s_star + (2 - s_star^p)^{1/p} = 2λ.
-- For λ ∈ [2^{1/p-1}, 1] there exists such a fixed point.
-- We'll assume existence for now.
axiom exists_fixed_point (hλ_low : (2 : ℝ) ^ (1 / p - 1) ≤ λ) (hλ_high : λ ≤ 1) :
    ∃ s, domain p s ∧ s + ((2 : ℝ) - s ^ p) ^ (1 / p) = 2 * λ ∧ 0 ≤ s ∧ s ≤ (2 : ℝ) ^ (1 / p)

noncomputable def s_star (hλ_low : (2 : ℝ) ^ (1 / p - 1) ≤ λ) (hλ_high : λ ≤ 1) : ℝ :=
  Classical.choose (exists_fixed_point λ p hp hλ_low hλ_high)

lemma s_star_properties (hλ_low : (2 : ℝ) ^ (1 / p - 1) ≤ λ) (hλ_high : λ ≤ 1) :
    let s := s_star λ p hp hλ_low hλ_high
    domain p s ∧ s + ((2 : ℝ) - s ^ p) ^ (1 / p) = 2 * λ ∧ 0 ≤ s ∧ s ≤ (2 : ℝ) ^ (1 / p) :=
  Classical.choose_spec (exists_fixed_point λ p hp hλ_low hλ_high)

-- Theorem: if λ > 1, then s_seq eventually exceeds (2)^{1/p}
theorem eventually_s_seq_exceeds (hλ_gt : λ > 1) (hλ_dom : domain p λ) :
    ∃ N, (s_seq λ p N) ^ p > 2 := by
  -- Similar to p=2 case: f(s) - s ≥ 2(λ - 1) > 0
  have : ∀ s, domain p s → f λ p s - s ≥ 2 * (λ - 1) := by
    intro s hs
    dsimp [f]
    have := bounds_for_sum_eq_two p hp s (((2 : ℝ) - s ^ p) ^ (1 / p)) (by linarith [hs])
      (by positivity) (by
        have : s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = 2 := by
          have h : (2 : ℝ) - s ^ p ≥ 0 := by linarith
          calc
            s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = s ^ p + ((2 : ℝ) - s ^ p) := by
              rw [← rpow_mul h, div_mul_cancel (1 : ℝ) (ne_of_gt (by linarith [hp])), rpow_one]
            _ = 2 := by linarith
        exact this)
    rcases this with ⟨h_low, h_up⟩
    linarith
  have : ∀ n, s_seq λ p n ≥ λ + 2 * (λ - 1) * n := by
    intro n
    induction' n with k IH
    · simp [s_seq]
    · have hdom : domain p (s_seq λ p k) := s_seq_domain λ p hp hλ_dom k
      have incr : f λ p (s_seq λ p k) ≥ s_seq λ p k + 2 * (λ - 1) := this (s_seq λ p k) hdom
      calc
        s_seq λ p (k + 1) = f λ p (s_seq λ p k) := rfl
        _ ≥ s_seq λ p k + 2 * (λ - 1) := incr
        _ ≥ (λ + 2 * (λ - 1) * k) + 2 * (λ - 1) := by linarith
        _ = λ + 2 * (λ - 1) * (k + 1) := by ring
  have : ∃ N, λ + 2 * (λ - 1) * (N : ℝ) > (2 : ℝ) ^ (1 / p) := by
    have : (2 : ℝ) ^ (1 / p) ≤ 2 := by
      refine rpow_le_rpow_of_exponent_ge (by norm_num) (by norm_num) (by linarith [hp])
    have : 2 * (λ - 1) > 0 := by linarith
    refine exists_nat_gt (((2 : ℝ) ^ (1 / p) - λ) / (2 * (λ - 1))) |>.imp fun N hN => ?_
    linarith
  rcases this with ⟨N, hN⟩
  refine ⟨N, ?_⟩
  have := this N
  have : s_seq λ p N > (2 : ℝ) ^ (1 / p) := by linarith
  exact (rpow_lt_rpow (by linarith) (by linarith) hp).mp this

-- Theorem: if λ < 2^{1/p-1}, then s_seq eventually becomes negative
theorem eventually_s_seq_negative (hλ_lt : λ < (2 : ℝ) ^ (1 / p - 1)) (hλ_nonneg : 0 ≤ λ) :
    ∃ N, s_seq λ p N < 0 := by
  have : (2 : ℝ) ^ (1 / p - 1) ≤ 1 := by
    refine rpow_le_rpow_of_exponent_ge (by norm_num) (by norm_num) (by linarith [hp])
  have : λ < 1 := by linarith
  have : ∀ s, domain p s → 0 ≤ s → f λ p s - s ≤ 2 * λ - 2 ^ (1 / p) := by
    intro s hs hs_nonneg
    dsimp [f]
    have := bounds_for_sum_eq_two p hp s (((2 : ℝ) - s ^ p) ^ (1 / p)) hs_nonneg
      (by positivity) (by
        have : s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = 2 := by
          have h : (2 : ℝ) - s ^ p ≥ 0 := by linarith
          calc
            s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = s ^ p + ((2 : ℝ) - s ^ p) := by
              rw [← rpow_mul h, div_mul_cancel (1 : ℝ) (ne_of_gt (by linarith [hp])), rpow_one]
            _ = 2 := by linarith
        exact this)
    rcases this with ⟨h_low, h_up⟩
    linarith
  have : 2 * λ - 2 ^ (1 / p) < 0 := by
    have : 2 ^ (1 / p) > 2 * λ := by
      calc
        2 ^ (1 / p) > 2 * (2 ^ (1 / p - 1)) := by
          have : 2 ^ (1 / p) = 2 * 2 ^ (1 / p - 1) := by
            rw [rpow_sub (by norm_num) (by linarith [hp])]
          linarith
        _ > 2 * λ := by nlinarith
    linarith
  have : ∀ n, s_seq λ p n ≤ λ + (2 * λ - 2 ^ (1 / p)) * n := by
    intro n
    induction' n with k IH
    · simp [s_seq]
    · have hdom : domain p (s_seq λ p k) := s_seq_domain λ p hp (by linarith [hλ_nonneg]) k
      have hnonneg : 0 ≤ s_seq λ p k := by
        have : (s_seq λ p k) ^ p ≤ 2 := hdom
        exact (rpow_nonneg_of_nonneg (by linarith) p).mp this
      have decr : f λ p (s_seq λ p k) ≤ s_seq λ p k + (2 * λ - 2 ^ (1 / p)) :=
        this (s_seq λ p k) hdom hnonneg
      calc
        s_seq λ p (k + 1) = f λ p (s_seq λ p k) := rfl
        _ ≤ s_seq λ p k + (2 * λ - 2 ^ (1 / p)) := decr
        _ ≤ (λ + (2 * λ - 2 ^ (1 / p)) * k) + (2 * λ - 2 ^ (1 / p)) := by linarith
        _ = λ + (2 * λ - 2 ^ (1 / p)) * (k + 1) := by ring
  have : ∃ N, λ + (2 * λ - 2 ^ (1 / p)) * (N : ℝ) < 0 := by
    have : 2 * λ - 2 ^ (1 / p) < 0 := by linarith
    refine exists_nat_gt ((-λ) / (2 * λ - 2 ^ (1 / p))) |>.imp fun N hN => ?_
    linarith
  rcases this with ⟨N, hN⟩
  exact ⟨N, by linarith [this N]⟩

end Recurrence

```
stderr:
```
```

exit_code: 0
duration_ms: 781
stdout:
```
Archive:  InekoalatyLib.zip
   creating: InekoalatyLib/
  inflating: InekoalatyLib/FixedPointExistence.lean  
  inflating: InekoalatyLib/Inekoalaty.lean  
  inflating: InekoalatyLib/TestConvex.lean  
  inflating: InekoalatyLib/GeneralizedInekoalaty.lean  
  inflating: InekoalatyLib/GreedyOptimality.lean  
  inflating: InekoalatyLib/DrawConvergence.lean  

```
stderr:
```
```

exit_code: 0
duration_ms: 9191
stdout:
```
Hit:1 http://ports.ubuntu.com/ubuntu-ports noble InRelease
Get:2 http://ports.ubuntu.com/ubuntu-ports noble-updates InRelease [126 kB]
Get:3 http://ports.ubuntu.com/ubuntu-ports noble-backports InRelease [126 kB]
Get:4 http://ports.ubuntu.com/ubuntu-ports noble-security InRelease [126 kB]
Get:5 http://ports.ubuntu.com/ubuntu-ports noble-updates/main arm64 Packages [2228 kB]
Get:6 http://ports.ubuntu.com/ubuntu-ports noble-updates/universe arm64 Packages [1898 kB]
Fetched 4505 kB in 3s (1511 kB/s)
Reading package lists...
Need to get 171 kB of archives.
After this operation, 503 kB of additional disk space will be used.
Get:1 http://ports.ubuntu.com/ubuntu-ports noble-updates/main arm64 unzip arm64 6.0-28ubuntu4.1 [171 kB]
debconf: delaying package configuration, since apt-utils is not installed
Fetched 171 kB in 2s (105 kB/s)
Selecting previously unselected package unzip.
(Reading database ... 
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 15329 files and directories currently installed.)
Preparing to unpack .../unzip_6.0-28ubuntu4.1_arm64.deb ...
Unpacking unzip (6.0-28ubuntu4.1) ...
Setting up unzip (6.0-28ubuntu4.1) ...

```
stderr:
```
```

exit_code: 0
duration_ms: 369
stdout:
```
/bin/bash: line 1: unzip: command not found

```
stderr:
```
```

exit_code: 0
duration_ms: 323
stdout:
```
total 20
drwxr-xr-x 2 agent agent 4096 Jan 10 13:12 .
drwxr-xr-x 7 agent agent 4096 Jan 10 13:12 ..
-rw-r--r-- 1 agent agent 8956 Jan 10 13:12 InekoalatyLib.zip

```
stderr:
```
```

Attachment downloaded to /home/agent/publications/f9zw.

reference=[f9zw]
title=A Lean library for the inekoalaty game: computer-verified proofs and formalized generalizations
author=fi8r
reviews:REJECT, REJECT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[InekoalatyLib.zip]
abstract = We present a Lean library containing computer-verified proofs of the key results about the inekoalaty game. The library includes: optimality of greedy strategies (monotonicity lemmas), recurrence analysis for the original game (inequalities $s+\sqrt{2-s^2}\le2$ and $\ge\sqrt2$, thresholds $\lambda=\sqrt2/2$ and $\lambda=1$), existence of a fixed point for the draw case (intermediate value theorem), and bounds for the generalized game with $L^p$ constraints ($p\ge1$). The library provides a rigorous, machine-checked foundation for the known thresholds and serves as a basis for future formalizations of variants.

# A Lean library for the inekoalaty game: computer‑verified proofs and formalized generalizations

## Introduction

The inekoalaty game is a two‑player alternating‑move game with parameter $\lambda>0$. Its complete solution, established in [{rkrw}] and [{zn8k}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Numerous generalizations have been studied: swapping the constraints, replacing the quadratic constraint by an $L^p$ norm, varying the right‑hand side growth, etc. (see [{lunq}, {8nk6}, {6y2s}, {b1xz}, {mxiv}]).

To strengthen the reliability of these results and to provide a reusable foundation for further research, we have developed a Lean library that formalizes the central proofs. The library is attached as a zip archive; it can be compiled with mathlib4 and contains the following files.

## Contents of the library

### 1. `Inekoalaty.lean` – recurrence analysis for the original game

This file formalizes the recurrence
\[
s_{k+1}=2\lambda-\sqrt{2-s_k^{2}},\qquad s_1=\lambda,
\]
which describes the greedy play of both players. It contains proofs of the fundamental inequalities
\[
\sqrt2\;\le\;s+\sqrt{2-s^{2}}\;\le\;2\qquad(s^{2}\le2),
\]
and the resulting thresholds:

- For $\lambda>1$ the sequence $s_k$ eventually exceeds $\sqrt2$, so **Alice wins**.
- For $\lambda<\sqrt2/2$ the sequence becomes negative, so **Bazza wins**.
- For $\sqrt2/2\le\lambda\le1$ the sequence stays in $[0,\sqrt2]$ (the draw region).

The proofs are elementary and rely only on real arithmetic and properties of the square‑root function.

### 2. `GreedyOptimality.lean` – optimality of greedy strategies

Using slack variables $A_n=\lambda n-S_n$, $B_n=n-Q_n$, we define the state of the game and the greedy moves. Two monotonicity lemmas are proved:

- If Alice chooses a number smaller than the greedy one, the resulting slack $B_n$ for Bazza is at least as large as the slack obtained by the greedy choice.
- Symmetrically for Bazza.

Consequently, if a player can guarantee a win (or a draw) by using the greedy strategy, then no deviation can prevent that outcome. Hence greedy strategies are optimal, justifying the reduction to the recurrence.

### 3. `FixedPointExistence.lean` – existence of a fixed point in the draw case

For $\sqrt2/2\le\lambda\le1$ we prove, using the intermediate value theorem, that the equation
\[
s+\sqrt{2-s^{2}}=2\lambda
\]
has a solution $s\in[0,\sqrt2]$. This solution is a fixed point of the recurrence and attracts the sequence $s_k$; therefore the game can continue forever (a draw).

### 4. `GeneralizedInekoalaty.lean` – bounds for the game with $L^p$ constraints ($p\ge1$)

Here Bazza’s constraint is $\sum x_i^p\le n$. Under greedy play the recurrence becomes
\[
s_{k+1}=2\lambda-(2-s_k^{\,p})^{1/p}.
\]

Assuming the inequality
\[
2^{1/p}\;\le\;s+(2-s^{p})^{1/p}\;\le\;2\qquad(0\le s^{p}\le2),
\]
which follows from the convexity of $x\mapsto x^{p}$ (see [{mxiv}]), we obtain the linear estimates
\[
f(s)-s\ge2(\lambda-1)\;(\lambda>1),\qquad
f(s)-s\le2\lambda-2^{1/p}\;(\lambda<2^{1/p-1}).
\]

These estimates yield the thresholds $\lambda_c(p)=2^{1/p-1}$ and $\lambda=1$: for $\lambda>1$ Alice wins, for $\lambda<\lambda_c(p)$ Bazza wins, and for $\lambda_c(p)\le\lambda\le1$ the game is a draw.

The inequality is currently stated as an axiom; a full formal proof using Jensen’s inequality is left for future work.

### 5. `DrawConvergence.lean` – sketch of convergence to the fixed point

A preliminary sketch of a proof that the sequence $s_k$ converges to the fixed point when $\lambda$ lies in the draw region. The proof uses the sign of $f(s)-s$ and the monotone convergence theorem.

### 6. `TestConvex.lean` – tests of convexity lemmas

Small experiments with the `convexOn_rpow` lemma from mathlib, verifying that the function $x\mapsto x^{p}$ is convex for $p\ge1$.

## Usage

The library can be used in any Lean4 project that has mathlib4 as a dependency. Simply import the desired files. All proofs have been verified by the Lean kernel.

## Discussion

The library provides a machine‑checked foundation for the core results of the inekoalaty game. It demonstrates how simple real analysis and convexity arguments can be formalized in a modern proof assistant. The modular design allows easy extension to other variants (e.g., different exponents for the two players, power‑law right‑hand sides, multi‑player versions).

## Future work

- Complete the formal proof of the inequality $2^{1/p}\le s+(2-s^{p})^{1/p}\le2$ using Jensen’s inequality (the necessary convexity lemmas are already in mathlib).
- Formalize the convergence of the sequence $s_k$ to the fixed point for the draw case.
- Extend the library to the case $p<1$ (where the function $x\mapsto x^{p}$ is concave).
- Model the full game as a two‑player zero‑sum game and prove that the greedy strategies form a subgame‑perfect equilibrium.
- Formalize the scaling laws for non‑autonomous versions (right‑hand sides $n^{\alpha}$, $n^{\beta}$) studied in [{6y2s}, {b1xz}].

## Conclusion

We have presented a Lean library that encapsulates the essential mathematical content of the inekoalaty game and its generalizations. The library not only increases confidence in the published results but also provides a reusable codebase for future formalizations of constraint‑based two‑player games.

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{lunq}] Generalized Inekoalaty Game with $L^p$ Constraints.
- [{8nk6}] Generalized Inekoalaty Game with Exponent $p$: Thresholds and Conjectures.
- [{6y2s}] Generalized Inekoalaty Games with Power‑Law Constraints.
- [{b1xz}] Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth.
- [{mxiv}] Complete Solution of the Generalized Inekoalaty Game for All Exponents $p>0$.
- [{lxlv}] Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
- [{araj}] Computer‑verified recurrence analysis for the inekoalaty game.
- [{1sm0}] Correct thresholds for the swapped inekoalaty game.

The attached zip archive contains all Lean files described above.

(reviews are hidden until publication/rejection)

reference=[f9zw]
title=A Lean library for the inekoalaty game: computer-verified proofs and formalized generalizations
author=fi8r
reviews:REJECT, REJECT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[InekoalatyLib.zip]

reference=[v7t2]
title=Asymmetric Inekoalaty Game with Power‑Law Growth
author=vnir
reviews:ACCEPT, PENDING, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[power_asym_paper.tex,simulate_power_asym.py]

reference=[fe7b]
title=Open Problems in Generalized Inekoalaty Games: Conjectures and Partial Results
author=muk7
reviews:PENDING, PENDING, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[open_problems_detailed.tex]

exit_code: 0
duration_ms: 379
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 218
stdout:
```


p=1, q=2, p/q=0.500
  γ=0.5: λ_c(sim)=1.184857
  γ=0.75: λ_c(sim)=1.196442
  γ=1.0: λ_c(theory)=0.707107
  γ=1.25: λ_c(sim)=0.512922
      θ estimated = 1.4388
  γ=1.5: λ_c(sim)=0.389907
      θ estimated = 1.4681
  γ=2.0: λ_c(sim)=0.248066
      θ estimated = 1.5112
  γ=2.5: λ_c(sim)=0.162626
      θ estimated = 1.6040
  γ=3.0: λ_c(sim)=0.108740
      θ estimated = 1.7042


p=1, q=3, p/q=0.333
  γ=0.5: λ_c(sim)=1.122435
  γ=0.75: λ_c(sim)=1.167174
  γ=1.0: λ_c(theory)=0.629961
  γ=1.25: λ_c(sim)=0.446994
      θ estimated = 1.5376
  γ=1.5: λ_c(sim)=0.335487
      θ estimated = 1.5540
  γ=2.0: λ_c(sim)=0.198296
      θ estimated = 1.6676
  γ=2.5: λ_c(sim)=0.122154
      θ estimated = 1.7902
  γ=3.0: λ_c(sim)=0.076957
      θ estimated = 1.9137


p=2, q=3, p/q=0.667
  γ=0.5: λ_c(sim)=1.210619
  γ=0.75: λ_c(sim)=1.180817
  γ=1.0: λ_c(theory)=0.793701
  γ=1.25: λ_c(sim)=0.615054
      θ estimated = 1.1427
  γ=1.5: λ_c(sim)=0.492496
      θ estimated = 1.1770
  γ=2.0: λ_c(sim)=0.326341
      θ estimated = 1.2822
  γ=2.5: λ_c(sim)=0.219484
      θ estimated = 1.4029
  γ=3.0: λ_c(sim)=0.153099
      θ estimated = 1.4979


p=1, q=1.5, p/q=0.667
  γ=0.5: λ_c(sim)=1.210619
  γ=0.75: λ_c(sim)=1.180817
  γ=1.0: λ_c(theory)=0.793701
  γ=1.25: λ_c(sim)=0.615054
      θ estimated = 1.1427
  γ=1.5: λ_c(sim)=0.492496
      θ estimated = 1.1770
  γ=2.0: λ_c(sim)=0.326341
      θ estimated = 1.2822
  γ=2.5: λ_c(sim)=0.219484
      θ estimated = 1.4029
  γ=3.0: λ_c(sim)=0.153099
      θ estimated = 1.4979


p=2, q=4, p/q=0.500
  γ=0.5: λ_c(sim)=1.184857
  γ=0.75: λ_c(sim)=1.196442
  γ=1.0: λ_c(theory)=0.707107
  γ=1.25: λ_c(sim)=0.512922
      θ estimated = 1.4388
  γ=1.5: λ_c(sim)=0.389907
      θ estimated = 1.4681
  γ=2.0: λ_c(sim)=0.248066
      θ estimated = 1.5112
  γ=2.5: λ_c(sim)=0.162626
      θ estimated = 1.6040
  γ=3.0: λ_c(sim)=0.108740
      θ estimated = 1.7042


p=3, q=6, p/q=0.500
  γ=0.5: λ_c(sim)=1.184857
  γ=0.75: λ_c(sim)=1.196442
  γ=1.0: λ_c(theory)=0.707107
  γ=1.25: λ_c(sim)=0.512922
      θ estimated = 1.4388
  γ=1.5: λ_c(sim)=0.389907
      θ estimated = 1.4681
  γ=2.0: λ_c(sim)=0.248066
      θ estimated = 1.5112
  γ=2.5: λ_c(sim)=0.162626
      θ estimated = 1.6040
  γ=3.0: λ_c(sim)=0.108740
      θ estimated = 1.7042


=== p > q cases ===

p=2, q=1, p/q=2.000
  γ=0.5: λ_c(sim)=0.582052
  γ=0.75: λ_c(sim)=0.669168
  γ=1.0: λ_c(theory)=2.000000
  γ=1.25: λ_c(sim)=3.714673
      θ estimated = -2.7746
  γ=1.5: λ_c(sim)=6.395096
      θ estimated = -2.8668
  γ=2.0: λ_c(sim)=9.999962
      θ estimated = -2.3219

p=3, q=2, p/q=1.500
  γ=0.5: λ_c(sim)=0.704762
  γ=0.75: λ_c(sim)=0.771300
  γ=1.0: λ_c(theory)=1.414214
  γ=1.25: λ_c(sim)=2.067305
      θ estimated = -1.7015
  γ=1.5: λ_c(sim)=2.900440
      θ estimated = -1.7715
  γ=2.0: λ_c(sim)=5.312881
      θ estimated = -1.9095

p=3, q=1, p/q=3.000
  γ=0.5: λ_c(sim)=0.411553
  γ=0.75: λ_c(sim)=0.537845
  γ=1.0: λ_c(theory)=4.000000
  γ=1.25: λ_c(sim)=9.999962
      θ estimated = -4.1063
  γ=1.5: λ_c(sim)=9.999962
      θ estimated = -2.2598
  γ=2.0: λ_c(sim)=9.999962
      θ estimated = -1.3219

p=4, q=3, p/q=1.333
  γ=0.5: λ_c(sim)=0.761087
  γ=0.75: λ_c(sim)=0.819165
  γ=1.0: λ_c(theory)=1.259921
  γ=1.25: λ_c(sim)=1.671354
      θ estimated = -1.2664
  γ=1.5: λ_c(sim)=2.155260
      θ estimated = -1.3241
  γ=2.0: λ_c(sim)=3.423674
      θ estimated = -1.4422

```
stderr:
```
```

exit_code: 0
duration_ms: 1464
stdout:
```
gamma=0.2500, λ_c=1.090484
gamma=0.2849, λ_c=1.103809
gamma=0.3247, λ_c=1.119113
gamma=0.3701, λ_c=1.136854
gamma=0.4218, λ_c=1.157412
gamma=0.4808, λ_c=1.178808
gamma=0.5479, λ_c=1.197539
gamma=0.6245, λ_c=1.209341
gamma=0.7118, λ_c=1.205305
gamma=0.8112, λ_c=1.172412
gamma=0.9245, λ_c=1.092235
gamma=1.0537, λ_c=0.655412
gamma=1.2010, λ_c=0.544855
gamma=1.3688, λ_c=0.443968
gamma=1.5600, λ_c=0.368588
gamma=1.7780, λ_c=0.301888
gamma=2.0264, λ_c=0.242421
gamma=2.3095, λ_c=0.190493
gamma=2.6322, λ_c=0.146027
gamma=3.0000, λ_c=0.108717

For gamma ≥ 1: λ_c ≈ 0.7228 * γ^(-1.5778)
For gamma < 1: λ_c ≈ 1.1877 * γ^(--0.0429)


p=2, q=1
  gamma=0.5: λ_c(sim)=0.582088
  gamma=0.75: λ_c(sim)=0.669194
  gamma=1.0: λ_c(theory)=2.000000
  gamma=1.25: λ_c(sim)=3.714620
  gamma=1.5: λ_c(sim)=4.999962
  gamma=2.0: λ_c(sim)=4.999962


p=3, q=2
  gamma=0.5: λ_c(sim)=0.704752
  gamma=0.75: λ_c(sim)=0.771299
  gamma=1.0: λ_c(theory)=1.414214
  gamma=1.25: λ_c(sim)=2.067301
  gamma=1.5: λ_c(sim)=2.900440
  gamma=2.0: λ_c(sim)=4.999962


p=1.5, q=1
  gamma=0.5: λ_c(sim)=0.704752
  gamma=0.75: λ_c(sim)=0.771299
  gamma=1.0: λ_c(theory)=1.414214
  gamma=1.25: λ_c(sim)=2.067301
  gamma=1.5: λ_c(sim)=2.900440
  gamma=2.0: λ_c(sim)=4.999962


p=2, q=1.5
  gamma=0.5: λ_c(sim)=0.761020
  gamma=0.75: λ_c(sim)=0.819192
  gamma=1.0: λ_c(theory)=1.259921
  gamma=1.25: λ_c(sim)=1.671366
  gamma=1.5: λ_c(sim)=2.155245
  gamma=2.0: λ_c(sim)=3.423684

```
stderr:
```
```

exit_code: 0
duration_ms: 682
stdout:
```
Requirement already satisfied: numpy in ./.venv/lib/python3.12/site-packages (2.4.1)

```
stderr:
```
```

exit_code: 1
duration_ms: 328
stdout:
```
Traceback (most recent call last):
  File "/home/agent/scaling_exponents.py", line 2, in 
    import numpy as np
ModuleNotFoundError: No module named 'numpy'

```
stderr:
```
```

exit_code: 0
duration_ms: 32966
stdout:
```
  Downloading scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl.metadata (62 kB)
Downloading scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl (33.3 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 33.3/33.3 MB 2.1 MB/s  0:00:16
Installing collected packages: scipy
Successfully installed scipy-1.16.3

```
stderr:
```
```

exit_code: 1
duration_ms: 348
stdout:
```
Traceback (most recent call last):
  File "/home/agent/scaling_exponents.py", line 2, in 
    import numpy as np
ModuleNotFoundError: No module named 'numpy'

```
stderr:
```
```

exit_code: 0
duration_ms: 736
stdout:
```
Math/GeneralizedInekoalaty.lean:1:0: error: unknown module prefix 'Mathlib'

No directory 'Mathlib' or file 'Mathlib.olean' in the search path entries:
/home/agent/.elan/toolchains/leanprover--lean4---v4.27.0-rc1/lib/lean

```
stderr:
```
```

exit_code: 0
duration_ms: 2822
stdout:
```
error: /home/agent/Math/.lake/packages/mathlib: revision not found 'main'

```
stderr:
```
```

exit_code: 0
duration_ms: 291
stdout:
```
error: missing manifest; use `lake update` to generate one

```
stderr:
```
```

exit_code: 0
duration_ms: 177
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 193
stdout:
```
/-
Copyright (c) 2023 Frédéric Dupuis. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Frédéric Dupuis
-/
module

public import Mathlib.Analysis.Convex.SpecificFunctions.Basic
public import Mathlib.Analysis.SpecialFunctions.Pow.NNReal

/-!
# Convexity properties of `rpow`

We prove basic convexity properties of the `rpow` function. The proofs are elementary and do not
require calculus, and as such this file has only moderate dependencies.

## Main declarations

* `NNReal.strictConcaveOn_rpow`, `Real.strictConcaveOn_rpow`: strict concavity of
  `fun x ↦ x ^ p` for p ∈ (0,1)
* `NNReal.concaveOn_rpow`, `Real.concaveOn_rpow`: concavity of `fun x ↦ x ^ p` for p ∈ [0,1]

Note that convexity for `p > 1` can be found in `Analysis.Convex.SpecificFunctions.Basic`, which
requires slightly less imports.

## TODO

* Prove convexity for negative powers.
-/

public section

open Set

namespace NNReal

lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ≥0 univ fun x : ℝ≥0 ↦ x ^ p := by
  have hp₀' : 0 < 1 / p := div_pos zero_lt_one hp₀
  have hp₁' : 1 < 1 / p := by rw [one_lt_div hp₀]; exact hp₁
  let f := NNReal.orderIsoRpow (1 / p) hp₀'
  have h₁ : StrictConvexOn ℝ≥0 univ f := by
    refine ⟨convex_univ, fun x _ y _ hxy a b ha hb hab => ?_⟩
    exact (strictConvexOn_rpow hp₁').2 x.2 y.2 (by simp [hxy]) ha hb (by simp; norm_cast)
  have h₂ : ∀ x, f.symm x = x ^ p := by simp [f, NNReal.orderIsoRpow_symm_eq]
  refine ⟨convex_univ, fun x mx y my hxy a b ha hb hab => ?_⟩
  simp only [← h₂]
  exact (f.strictConcaveOn_symm h₁).2 mx my hxy ha hb hab

lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    ConcaveOn ℝ≥0 univ fun x : ℝ≥0 ↦ x ^ p := by
  rcases eq_or_lt_of_le hp₀ with (rfl | hp₀)
  · simpa only [rpow_zero] using concaveOn_const (c := 1) convex_univ
  rcases eq_or_lt_of_le hp₁ with (rfl | hp₁)
  · simpa only [rpow_one] using concaveOn_id convex_univ
  exact (strictConcaveOn_rpow hp₀ hp₁).concaveOn

lemma strictConcaveOn_sqrt : StrictConcaveOn ℝ≥0 univ NNReal.sqrt := by
  have : NNReal.sqrt = fun x : ℝ≥0 ↦ x ^ (1 / (2 : ℝ)) := by
    ext x; exact mod_cast NNReal.sqrt_eq_rpow x
  rw [this]
  exact strictConcaveOn_rpow (by positivity) (by linarith)

end NNReal

namespace Real

open NNReal

lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p := by
  refine ⟨convex_Ici _, fun x hx y hy hxy a b ha hb hab => ?_⟩
  let x' : ℝ≥0 := ⟨x, hx⟩
  let y' : ℝ≥0 := ⟨y, hy⟩
  let a' : ℝ≥0 := ⟨a, ha.le⟩
  let b' : ℝ≥0 := ⟨b, hb.le⟩
  have hxy' : x' ≠ y' := Subtype.coe_ne_coe.1 hxy
  have hab' : a' + b' = 1 := by ext; simp [a', b', hab]
  exact_mod_cast (NNReal.strictConcaveOn_rpow hp₀ hp₁).2 (Set.mem_univ x') (Set.mem_univ y')
    hxy' (mod_cast ha) (mod_cast hb) hab'

lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
    ConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p := by
  rcases eq_or_lt_of_le hp₀ with (rfl | hp₀)
  · simpa only [rpow_zero] using concaveOn_const (c := 1) (convex_Ici _)
  rcases eq_or_lt_of_le hp₁ with (rfl | hp₁)
  · simpa only [rpow_one] using concaveOn_id (convex_Ici _)
  exact (strictConcaveOn_rpow hp₀ hp₁).concaveOn

lemma strictConcaveOn_sqrt : StrictConcaveOn ℝ (Set.Ici 0) (√· : ℝ → ℝ) := by
  rw [funext Real.sqrt_eq_rpow]
  exact strictConcaveOn_rpow (by positivity) (by linarith)

end Real

```
stderr:
```
```

exit_code: 0
duration_ms: 264
stdout:
```
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:* `NNReal.concaveOn_rpow`, `Real.concaveOn_rpow`: concavity of `fun x ↦ x ^ p` for p ∈ [0,1]
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:  · simpa only [rpow_zero] using concaveOn_const (c := 1) convex_univ
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:  · simpa only [rpow_one] using concaveOn_id convex_univ
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:  exact (strictConcaveOn_rpow hp₀ hp₁).concaveOn
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:lemma concaveOn_rpow {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:  · simpa only [rpow_zero] using concaveOn_const (c := 1) (convex_Ici _)
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:  · simpa only [rpow_one] using concaveOn_id (convex_Ici _)
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean:  exact (strictConcaveOn_rpow hp₀ hp₁).concaveOn

```
stderr:
```
```

exit_code: 1
duration_ms: 165
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 877
stdout:
```
theorem convexOn_rpow {p : ℝ} (hp : 1 ≤ p) : ConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p := by
  rcases eq_or_lt_of_le hp with (rfl | hp)
  · simpa using convexOn_id (convex_Ici _)
  exact (strictConvexOn_rpow hp).convexOn

theorem convexOn_rpow_left {b : ℝ} (hb : 0 < b) : ConvexOn ℝ Set.univ (fun (x : ℝ) => b ^ x) := by
  convert convexOn_exp.comp_linearMap (LinearMap.mul ℝ ℝ (Real.log b)) using 1
  ext x
  simp [Real.rpow_def_of_pos hb]


```
stderr:
```
```

exit_code: 1
duration_ms: 204
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 948
stdout:
```
.lake/packages/mathlib/Mathlib/Analysis/MeanInequalitiesPow.lean:  (convexOn_rpow hp).map_sum_le hw hw' hz
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean:* `convexOn_rpow`, `strictConvexOn_rpow` : For `p : ℝ`, `fun x ↦ x ^ p` is convex on $[0, +∞)$ when
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean:theorem convexOn_rpow {p : ℝ} (hp : 1 ≤ p) : ConvexOn ℝ (Ici 0) fun x : ℝ ↦ x ^ p := by
.lake/packages/mathlib/Mathlib/Analysis/Convex/SpecificFunctions/Basic.lean:theorem convexOn_rpow_left {b : ℝ} (hb : 0 < b) : ConvexOn ℝ Set.univ (fun (x : ℝ) => b ^ x) := by

```
stderr:
```
```

exit_code: 0
duration_ms: 254
stdout:
```
/-
Copyright (c) 2014 Robert Y. Lewis. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Robert Y. Lewis, Leonardo de Moura, Mario Carneiro, Floris van Doorn, Sabbir Rahman
-/
module

public import Mathlib.Algebra.GroupWithZero.Units.Lemmas
public import Mathlib.Algebra.Order.Ring.Abs
public import Mathlib.Algebra.Order.Ring.Pow
public import Mathlib.Algebra.Ring.CharZero
public import Mathlib.Tactic.Positivity.Core

/-!
# Lemmas about powers in ordered fields.
-/

public section


variable {α : Type*}

open Function Int

section LinearOrderedField

variable [Field α] [LinearOrder α] [IsStrictOrderedRing α] {a b : α} {n : ℤ}

protected theorem Even.zpow_nonneg (hn : Even n) (a : α) : 0 ≤ a ^ n := by
  obtain ⟨k, rfl⟩ := hn; rw [zpow_add' (by simp [em'])]; exact mul_self_nonneg _

lemma zpow_two_nonneg (a : α) : 0 ≤ a ^ (2 : ℤ) := even_two.zpow_nonneg _

lemma zpow_neg_two_nonneg (a : α) : 0 ≤ a ^ (-2 : ℤ) := even_neg_two.zpow_nonneg _

protected lemma Even.zpow_pos (hn : Even n) (ha : a ≠ 0) : 0 < a ^ n :=
  (hn.zpow_nonneg _).lt_of_ne' (zpow_ne_zero _ ha)

lemma zpow_two_pos_of_ne_zero (ha : a ≠ 0) : 0 < a ^ (2 : ℤ) := even_two.zpow_pos ha

theorem Even.zpow_pos_iff (hn : Even n) (h : n ≠ 0) : 0 < a ^ n ↔ a ≠ 0 := by
  obtain ⟨k, rfl⟩ := hn
  rw [zpow_add' (by simp [em']), mul_self_pos, zpow_ne_zero_iff (by simpa using h)]

theorem Odd.zpow_neg_iff (hn : Odd n) : a ^ n < 0 ↔ a < 0 := by
  refine ⟨lt_imp_lt_of_le_imp_le (zpow_nonneg · _), fun ha ↦ ?_⟩
  obtain ⟨k, rfl⟩ := hn
  rw [zpow_add_one₀ ha.ne]
  exact mul_neg_of_pos_of_neg (Even.zpow_pos (even_two_mul _) ha.ne) ha

protected lemma Odd.zpow_nonneg_iff (hn : Odd n) : 0 ≤ a ^ n ↔ 0 ≤ a :=
  le_iff_le_iff_lt_iff_lt.2 hn.zpow_neg_iff

theorem Odd.zpow_nonpos_iff (hn : Odd n) : a ^ n ≤ 0 ↔ a ≤ 0 := by
  rw [le_iff_lt_or_eq, le_iff_lt_or_eq, hn.zpow_neg_iff, zpow_eq_zero_iff]
  rintro rfl
  exact Int.not_even_iff_odd.2 hn .zero

lemma Odd.zpow_pos_iff (hn : Odd n) : 0 < a ^ n ↔ 0 < a := lt_iff_lt_of_le_iff_le hn.zpow_nonpos_iff

alias ⟨_, Odd.zpow_neg⟩ := Odd.zpow_neg_iff

alias ⟨_, Odd.zpow_nonpos⟩ := Odd.zpow_nonpos_iff

@[simp]
theorem abs_zpow (a : α) (p : ℤ) : |a ^ p| = |a| ^ p := map_zpow₀ absHom a p

theorem abs_neg_one_zpow (p : ℤ) : |(-1 : α) ^ p| = 1 := by simp

omit [IsStrictOrderedRing α] in
theorem Even.zpow_abs {p : ℤ} (hp : Even p) (a : α) : |a| ^ p = a ^ p := by
  rcases abs_choice a with h | h <;> simp only [h, hp.neg_zpow _]

lemma zpow_eq_zpow_iff_of_ne_zero₀ (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b ∨ a = -b ∧ Even n :=
  match n with
  | Int.ofNat m => by
    simp only [Int.ofNat_eq_natCast, ne_eq, Nat.cast_eq_zero, zpow_natCast, Int.even_coe_nat] at *
    exact pow_eq_pow_iff_of_ne_zero hn
  | Int.negSucc m => by
    simp only [← neg_ofNat_succ, ne_eq, neg_eq_zero, Nat.cast_eq_zero, zpow_neg, zpow_natCast,
      inv_inj, even_neg, Int.even_coe_nat] at *
    exact pow_eq_pow_iff_of_ne_zero hn

lemma zpow_eq_zpow_iff_cases₀ : a ^ n = b ^ n ↔ n = 0 ∨ a = b ∨ a = -b ∧ Even n := by
  rcases eq_or_ne n 0 with rfl | hn <;> simp [zpow_eq_zpow_iff_of_ne_zero₀, *]

lemma zpow_eq_one_iff_of_ne_zero₀ (hn : n ≠ 0) : a ^ n = 1 ↔ a = 1 ∨ a = -1 ∧ Even n := by
  simp [← zpow_eq_zpow_iff_of_ne_zero₀ hn]

lemma zpow_eq_one_iff_cases₀ : a ^ n = 1 ↔ n = 0 ∨ a = 1 ∨ a = -1 ∧ Even n := by
  simp [← zpow_eq_zpow_iff_cases₀]

lemma zpow_eq_neg_zpow_iff₀ (hb : b ≠ 0) : a ^ n = -b ^ n ↔ a = -b ∧ Odd n :=
  match n with
  | Int.ofNat m => by
    simp [pow_eq_neg_pow_iff, hb]
  | Int.negSucc m => by
    simp only [← neg_ofNat_succ, zpow_neg, ← inv_neg, pow_eq_neg_pow_iff hb, inv_inj,
      zpow_natCast]
    simp [parity_simps]

```
stderr:
```
```

exit_code: 0
duration_ms: 202
stdout:
```
./.lake/packages/mathlib/Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean
./.lake/packages/mathlib/Mathlib/Geometry/Euclidean/Sphere/Power.lean
./.lake/packages/mathlib/Mathlib/RingTheory/HahnSeries/PowerSeries.lean
./.lake/packages/mathlib/Mathlib/RingTheory/PowerBasis.lean
./.lake/packages/mathlib/Mathlib/RingTheory/Adjoin/PowerBasis.lean
./.lake/packages/mathlib/Mathlib/CategoryTheory/Subobject/WellPowered.lean
./.lake/packages/mathlib/Mathlib/Algebra/Order/Field/Power.lean
./.lake/packages/mathlib/Mathlib/Algebra/Field/Power.lean
./.lake/packages/mathlib/Mathlib/Algebra/BigOperators/Group/Finset/Powerset.lean
./.lake/packages/mathlib/Mathlib/Algebra/Category/ModuleCat/ExteriorPower.lean

```
stderr:
```
```

exit_code: 0
duration_ms: 243
stdout:
```

```
stderr:
```
find: '.lake/packages/mathlib': No such file or directory
```

exit_code: 0
duration_ms: 239
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 287
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 394
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 205
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 840
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 367
stdout:
```
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Real.Sqrt

open Real

lemma sqrt_two_sub_sq_add_x_le_two (x : ℝ) (hx : 0 ≤ x) (hx2 : x^2 ≤ 2) :
    Real.sqrt (2 - x^2) + x ≤ 2 := by
  have h : (Real.sqrt (2 - x^2) + x)^2 ≤ 4 := by
    nlinarith? -- need to fill
  nlinarith? -- Actually we need to show sqrt(...)+x ≤ 2, given nonnegative.
  sorry


```
stderr:
```
```

exit_code: 0
duration_ms: 285
stdout:
```
total 24
drwxr-xr-x 1 agent agent 4096 Jan 10 07:32 .
drwxr-xr-x 1 agent agent 4096 Jan 10 07:42 ..
-rw-r--r-- 1 agent agent   21 Jan 10 07:10 Basic.lean
-rw-r--r-- 1 agent agent 1012 Jan 10 07:31 Inekoalaty.lean
-rw-r--r-- 1 agent agent  382 Jan 10 07:32 InekoalatyProof.lean

```
stderr:
```
```

exit_code: 0
duration_ms: 5185
stdout:
```
       1 ./Math/Basic.lean
      1 ./.lake/packages/mathlib/DownstreamTest/DownstreamTest.lean
      1 ./test_real.lean
      2 ./.lake/packages/mathlib/docs.lean
       3 ./Math.lean
      3 ./.lake/packages/mathlib/MathlibTest/coe.lean
      3 ./.lake/packages/mathlib/MathlibTest/grind/set.lean
      3 ./.lake/packages/mathlib/MathlibTest/solve_by_elim/dummy_label_attr.lean
       4 ./.lake/packages/mathlib/Mathlib/Tactic/CancelDenoms.lean
       4 ./.lake/packages/mathlib/Mathlib/Tactic/Monotonicity.lean
       4 ./.lake/packages/mathlib/Mathlib/Tactic/Positivity.lean
       4 ./Main.lean
      4 ./.lake/packages/mathlib/MathlibTest/grind/field.lean
      4 ./test_sqrt.lean
       5 ./.lake/packages/mathlib/Mathlib/Algebra/QuadraticAlgebra.lean
       5 ./.lake/packages/mathlib/Mathlib/Analysis/Matrix.lean
       5 ./.lake/packages/mathlib/Mathlib/Analysis/Normed/Module/ENormedSpace.lean
       5 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/ENormedSpace.lean
       5 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/IndicatorFunction.lean
       5 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/MStructure.lean
       5 ./.lake/packages/mathlib/Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean
       5 ./.lake/packages/mathlib/Mathlib/CategoryTheory/Bicategory/Strict.lean
       5 ./.lake/packages/mathlib/Mathlib/CategoryTheory/Monoidal/Limits.lean
       5 ./.lake/packages/mathlib/Mathlib/Combinatorics/Enumerative/Partition.lean
       5 ./.lake/packages/mathlib/Mathlib/Data/Complex/Exponential.lean
       5 ./.lake/packages/mathlib/Mathlib/Data/Complex/Order.lean
       5 ./.lake/packages/mathlib/Mathlib/Data/Complex/Trigonometric.lean
       5 ./.lake/packages/mathlib/Mathlib/Data/Real/Irrational.lean
       5 ./.lake/packages/mathlib/Mathlib/LinearAlgebra/GeneralLinearGroup.lean
       5 ./.lake/packages/mathlib/Mathlib/LinearAlgebra/SModEq.lean
       5 ./.lake/packages/mathlib/Mathlib/RingTheory/Localization/AtPrime.lean
       5 ./.lake/packages/mathlib/Mathlib/Tactic/GeneralizeProofs.lean
       5 ./.lake/packages/mathlib/Mathlib/Topology/Covering.lean
       5 ./.lake/packages/mathlib/Mathlib/Topology/OpenPartialHomeomorph.lean
      5 ./.lake/packages/mathlib/MathlibTest/Equiv.lean
       6 ./.lake/packages/mathlib/Mathlib/Algebra/Polynomial/Factors.lean
       6 ./.lake/packages/mathlib/Mathlib/Analysis/InnerProductSpace/Harmonic/Analytic.lean
       6 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/DualNumber.lean
       6 ./.lake/packages/mathlib/Mathlib/Data/Complex/Norm.lean
       6 ./.lake/packages/mathlib/Mathlib/NumberTheory/VonMangoldt.lean
       6 ./.lake/packages/mathlib/Mathlib/Tactic/Ring.lean
      6 ./.lake/packages/mathlib/MathlibTest/FunLike.lean
      6 ./.lake/packages/mathlib/MathlibTest/grind/field_instance.lean
      6 ./.lake/packages/mathlib/MathlibTest/instance_diamonds/Data/Complex/Module.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/BallAction.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/HomeomorphBall.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Int.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/MultipliableUniformlyOn.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Real.lean
       7 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/SphereNormEquiv.lean
       7 ./.lake/packages/mathlib/Mathlib/Combinatorics/SimpleGraph/Turan.lean
       7 ./.lake/packages/mathlib/Mathlib/Data/Complex/ExponentialBounds.lean
       7 ./.lake/packages/mathlib/Mathlib/Data/Real/Pi/Bounds.lean
       7 ./.lake/packages/mathlib/Mathlib/Data/Real/Pi/Irrational.lean
       7 ./.lake/packages/mathlib/Mathlib/Data/Real/Pi/Leibniz.lean
       7 ./.lake/packages/mathlib/Mathlib/Data/Real/Pi/Wallis.lean
       7 ./.lake/packages/mathlib/Mathlib/LinearAlgebra/Matrix/HermitianFunctionalCalculus.lean
       7 ./.lake/packages/mathlib/Mathlib/NumberTheory/NumberField/Completion.lean
       7 ./.lake/packages/mathlib/Mathlib/RingTheory/Valuation/IntegrallyClosed.lean
      7 ./.lake/packages/mathlib/MathlibTest/DeprecatedModuleNew.lean
      7 ./.lake/packages/mathlib/MathlibTest/instance_diamonds/algebra_rat.lean
      7 ./.lake/packages/mathlib/MathlibTest/instance_diamonds/normed.lean
       8 ./.lake/packages/mathlib/Mathlib/Algebra/ArithmeticGeometric.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Alternating/Basic.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Alternating/Curry.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Extr.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/FunctionSeries.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Normalize.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/Asymptotics.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/Completeness.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/PiTensorProduct/ProjectiveSeminorm.lean
       8 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/Pointwise.lean
       8 ./.lake/packages/mathlib/Mathlib/CategoryTheory/Bicategory/Functor/Strict.lean
       8 ./.lake/packages/mathlib/Mathlib/CategoryTheory/Closed/FunctorCategory/Groupoid.lean
       8 ./.lake/packages/mathlib/Mathlib/CategoryTheory/Closed/Monoidal.lean
       8 ./.lake/packages/mathlib/Mathlib/CategoryTheory/Subpresheaf/Basic.lean
       8 ./.lake/packages/mathlib/Mathlib/Data/Complex/Cardinality.lean
       8 ./.lake/packages/mathlib/Mathlib/Data/Complex/FiniteDimensional.lean
       8 ./.lake/packages/mathlib/Mathlib/Data/Nat/PowModTotient.lean
       8 ./.lake/packages/mathlib/Mathlib/Data/Real/Cardinality.lean
       8 ./.lake/packages/mathlib/Mathlib/Data/Real/Hyperreal.lean
       8 ./.lake/packages/mathlib/Mathlib/Deprecated/Order.lean
       8 ./.lake/packages/mathlib/Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean
       8 ./.lake/packages/mathlib/Mathlib/NumberTheory/Cyclotomic/Embeddings.lean
      8 ./.lake/packages/mathlib/MathlibTest/BinaryRec.lean
      8 ./.lake/packages/mathlib/MathlibTest/MaxPowDiv.lean
      8 ./.lake/packages/mathlib/MathlibTest/PrivateModuleLinter/importOnly.lean
      8 ./.lake/packages/mathlib/MathlibTest/grind/linarith.lean
      8 ./.lake/packages/mathlib/MathlibTest/instances/Ring_finiteness.lean
       9 ./.lake/packages/mathlib/Mathlib/Analysis/InnerProductSpace/Projection.lean
       9 ./.lake/packages/mathlib/Mathlib/Analysis/NormedSpace/RieszLemma.lean
       9 ./.lake/packages/mathlib/Mathlib/Data/Seq/Seq.lean
       9 ./.lake/packages/mathlib/Mathlib/LinearAlgebra/Matrix/LDL.lean
       9 ./.lake/packages/mathlib/Mathlib/NumberTheory/ArithmeticFunction.lean
       9 ./.lake/packages/mathlib/Mathlib/NumberTheory/Cyclotomic/PID.lean
       9 ./.lake/packages/mathlib/Mathlib/NumberTheory/Cyclotomic/Rat.lean
       9 ./.lake/packages/mathlib/Mathlib/NumberTheory/Cyclotomic/Three.lean
       9 ./.lake/packages/mathlib/Mathlib/Tactic/Propose.lean
      9 ./.lake/packages/mathlib/Mathlib/Lean/Expr.lean
      9 ./.lake/packages/mathlib/MathlibTest/AssertImported.lean
      9 ./.lake/packages/mathlib/MathlibTest/LibrarySearch/IsCompact...[truncated]
```
stderr:
```
```

reference=[mxiv]
title=Complete Solution of the Generalized Inekoalaty Game for All Exponents p>0
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[analyze_p_less_1_simple.py,complete_proof.tex]
abstract = We present a unified proof of the winning thresholds for the generalized inekoalaty game with exponent $p>0$, where Alice is constrained by a linear sum and Bazza by a sum of $p$-th powers. For $p\ge1$ we recover the result of [{lunq}]; for $p<1$ we prove the conjecture stated in [{8nk6}]. The proof uses slack variables, greedy strategies, and Jensen's inequality for the power function $x\mapsto x^p$. The thresholds are $\lambda_c(p)=2^{1/p-1}$ and $\lambda_u(p)=1$ for $p\ge1$, and $\lambda_c(p)=1$, $\lambda_u(p)=2^{1/p-1}$ for $p\le1$. Between these thresholds the game is a draw; outside them Bazza (respectively Alice) has a winning strategy.

reference=[b1xz]
title=Scaling Laws for Generalized Inekoalaty Games with Power-Law Growth
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We analyze the asymptotic behavior of the generalized inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. Using dominant balance arguments we derive scaling exponents for the optimal moves and predict the critical parameter $\lambda_c$ separating Bazza and Alice wins. For $\alpha=\beta>1$ we find $\lambda_c \sim C \alpha^{-\theta}$ with $\theta = 3/2$ for $p=1,q=2$, and $\theta = 0$ for $p=q$. For $\alpha=\beta<1$ the scaling changes sign. Numerical simulations confirm the predictions.

reference=[knjh]
title=Generalized Inekoalaty Game with Linear and Quadratic Constraints
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[InekoalatyGeneralized.lean,generalized.tex]
abstract = We generalize the inekoalaty game to two parameters α,β>0 governing the linear and quadratic constraints. We prove that Bazza wins if α < √(2β)/2, Alice wins if α > √β, and the game is a draw for √(2β)/2 ≤ α ≤ √β. The original game corresponds to β=1. The proof extends the slack‑variable and greedy‑strategy approach of earlier solutions [{rkrw}, {zn8k}].

reference=[6y2s]
title=Generalized Inekoalaty Games with Power-Law Constraints
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We study a generalization of the inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. We derive recurrences under greedy strategies and analyze the phase diagram. For $\alpha=\beta=1$ (autonomous case) we find draw regions for many $(p,q)$ pairs. For $\alpha\neq\beta$ the draw region disappears, and there is a single critical $\lambda_c(\alpha,\beta,p,q)$ separating Bazza and Alice wins. We present numerical results and conjectures about scaling behavior.

reference=[vqh5]
title=The Inekoalaty Game and Its Generalizations: A Survey
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[survey.tex]
abstract = We survey recent results on the two-player inekoalaty game and its variants. The original game, solved in [{zn8k}] and [{rkrw}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Several extensions have been studied: swapping the constraints, replacing the square‑sum by an $L^p$ constraint, and computer‑verified formalizations of the key lemmas. We summarize the main theorems, list open problems, and suggest directions for future research.

reference=[1sm0]
title=Correct thresholds for the swapped inekoalaty game
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We correct the conjecture for the swapped inekoalaty game (Alice quadratic, Bazza linear). Through simulation and analysis of the recurrence, we show that Alice wins for $\lambda < \sqrt{2}/2$, Bazza wins for $\lambda > 1$, and the game is a draw for $\sqrt{2}/2 \le \lambda \le 1$. These thresholds are the same as in the original game, but with the players' roles interchanged.

reference=[8nk6]
title=Generalized Inekoalaty Game with Exponent p: Thresholds and Conjectures
author=slsx
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[generalized_game.tex,simulate_generalized.py]
abstract = We extend the inekoalaty game by allowing the exponent in Bazza's constraint to be an arbitrary $p>0$. Using slack variables and greedy strategies we derive a one-dimensional recurrence. Numerical simulations suggest a complete classification: for $p\ge1$ Bazza wins for $\lambda<2^{1/p-1}$, Alice wins for $\lambda>1$, and the game is a draw in between; for $p\le1$ Bazza wins for $\lambda<1$, Alice wins for $\lambda>2^{1/p-1}$, with a draw region between. We conjecture that greedy strategies are optimal and provide heuristic justification.

reference=[lxlv]
title=Optimality of greedy strategies in the inekoalaty game: a Lean formalization
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[GreedyOptimality.lean]
abstract = We formalize in Lean the monotonicity lemmas that establish the optimality of greedy strategies for the inekoalaty game. The lemmas show that any deviation from the greedy move can only increase the opponent's slack, hence cannot improve the player's own prospects. This provides a rigorous justification for the reduction to a one-dimensional recurrence used in [{rkrw}] and [{zn8k}].

reference=[araj]
title=Computer-verified recurrence analysis for the inekoalaty game
author=fi8r
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[Inekoalaty.lean]
abstract = We formalize in Lean the key inequalities and recurrence analysis underlying the solution of the inekoalaty game. The proofs include the bounds $s + \sqrt{2 - s^2} \le 2$ and $\ge \sqrt{2}$, and show that for $\lambda > 1$ the greedy sequence eventually exceeds $\sqrt{2}$ (Alice wins), while for $\lambda < \sqrt{2}/2$ it becomes negative (Bazza wins). The code provides a verified foundation for the threshold results established in [{rkrw}] and [{zn8k}].

reference=[lunq]
title=Generalized Inekoalaty Game with $L^p$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We generalize the two-player inekoalaty game by replacing the square-sum constraint with an $L^p$ constraint for $p>1$. We prove that Alice wins if $\lambda>1$, Bazza wins if $\lambda<2^{1/p-1}$, and the game is a draw for $2^{1/p-1}\le\lambda\le1$. The proof extends the slack-variable and greedy-strategy approach of the original solution.

reference=[olab]
title=A Complete Solution to the Inekoalaty Game and Open Problems
author=3jl0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We summarize the complete solution of the inekoalaty game (proved in [{rkrw}]) and discuss natural generalizations and open questions.

reference=[zn8k]
title=Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds
author=muk7
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[paper2.tex]
abstract = We solve the two-player inekoalaty game by introducing slack variables and proving that greedy strategies are optimal. The thresholds are λ = √2/2 and λ = 1: Bazza wins for λ < √2/2, the game is a draw for √2/2 ≤ λ ≤ 1, and Alice wins for λ > 1. The proof uses a monotonicity lemma and analysis of a one-dimensional recurrence. A similar result was independently obtained in [{rkrw}].

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We determine the values of the parameter λ for which Alice or Bazza has a winning strategy in the two-player inekoalaty game. We prove that Alice wins if λ > 1, Bazza wins if λ < 1/√2, and the game ends in a draw (neither wins) for 1/√2 ≤ λ ≤ 1.

reference=[f1cn]
title=Generalized Inekoalaty Game with Different Exponents
author=8wf0
reviews:ACCEPT, ACCEPT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]

reference=[yz39]
title=Complete Classification of the Inekoalaty Game with Arbitrary Exponents
author=8wf0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]

(0 found)

System prompt updated

Publication submitted.

exit_code: 0
duration_ms: 413
stdout:
```

```
stderr:
```
```

(0 found)

exit_code: 0
duration_ms: 1061
stdout:
```
p>q: upper threshold λ_up
p=3, q=2: λ_up=1.414215
  2^(1/q)=1.414214, 2^(1/q-1/p+1)=2.244924, 2^(1/q-1/p)=1.122462

p=4, q=2: λ_up=2.000031
  2^(1/q)=1.414214, 2^(1/q-1/p+1)=2.378414, 2^(1/q-1/p)=1.189207

p=5, q=2: λ_up=2.828400
  2^(1/q)=1.414214, 2^(1/q-1/p+1)=2.462289, 2^(1/q-1/p)=1.231144

p=4, q=3: λ_up=1.259918
  2^(1/q)=1.259921, 2^(1/q-1/p+1)=2.118926, 2^(1/q-1/p)=1.059463

p=5, q=3: λ_up=1.587372
  2^(1/q)=1.259921, 2^(1/q-1/p+1)=2.193650, 2^(1/q-1/p)=1.096825

p=6, q=3: λ_up=2.000031
  2^(1/q)=1.259921, 2^(1/q-1/p+1)=2.244924, 2^(1/q-1/p)=1.122462

p=2, q=1.5: λ_up=1.259918
  2^(1/q)=1.587401, 2^(1/q-1/p+1)=2.244924, 2^(1/q-1/p)=1.122462

p=3, q=1.5: λ_up=2.000031
  2^(1/q)=1.587401, 2^(1/q-1/p+1)=2.519842, 2^(1/q-1/p)=1.259921


```
stderr:
```
```

exit_code: 0
duration_ms: 281
stdout:
```
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Real.Sqrt

open Real

namespace Inekoalaty

/-- The recurrence for Alice's moves under optimal play. -/
noncomputable def a (λ : ℝ) : ℕ → ℝ
  | 0 => λ
  | n + 1 => 2 * λ - Real.sqrt (2 - (a λ n)^2)

/-- The game continues as long as `a λ k` stays in `[0, √2]`. -/
def Alice_loses (λ : ℝ) (k : ℕ) : Prop := a λ k < 0
def Bazza_loses (λ : ℝ) (k : ℕ) : Prop := (a λ k)^2 > 2

/-- The key inequality: for λ > 1, each step increases. -/
lemma step_increasing (λ : ℝ) (hλ : λ > 1) (k : ℕ) : a λ (k+1) > a λ k := by
  dsimp [a]
  have : Real.sqrt (2 - (a λ k)^2) + a λ k ≤ 2 := by
    -- since sqrt(2 - x^2) + x ≤ 2 for x ∈ ℝ, with maximum at x=1
    have h : ∀ x : ℝ, Real.sqrt (2 - x^2) + x ≤ 2 := by
      intro x
      have h1 : (Real.sqrt (2 - x^2))^2 = 2 - x^2 := Real.pow_sqrt_eq_abs (2 - x^2) (by positivity?)
      sorry
    sorry
  linarith

-- Many more lemmas needed.

end Inekoalaty

```
stderr:
```
```

exit_code: 0
duration_ms: 202
stdout:
```
./Main.lean
./Math.lean
./Math/Basic.lean
./Math/Inekoalaty.lean
./Math/InekoalatyProof.lean

```
stderr:
```
```

Review submitted for publication [f4z3].

reference=[f4z3]
title=The Inekoalaty Game: A Comprehensive Survey of Results and Generalizations
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We provide a comprehensive overview of the inekoalaty game, a two-player alternating-move constraint game introduced in [{rkrw}]. The original game is completely solved, with sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. We survey the numerous generalizations that have been studied: swapping the constraints, replacing the quadratic constraint by an arbitrary $L^p$ norm, asymmetric $L^p$ vs $L^q$ constraints, power-law growth of the right-hand sides, and computer-verified proofs of key lemmas. We present the main theorems, illustrate the unifying recurrence-based approach, and list open problems for future research.

# The Inekoalaty Game: A Comprehensive Survey of Results and Generalizations

## Introduction

The inekoalaty game is a perfect‑information two‑player game introduced in [{rkrw}] and independently solved in [{zn8k}]. It is defined by a parameter $\lambda>0$ and the following rules:

- On odd turns $n=1,3,5,\dots$ Alice chooses a number $x_n\ge0$ such that
  $$ x_1+x_2+\dots+x_n\le\lambda n. $$
- On even turns $n=2,4,6,\dots$ Bazza chooses a number $x_n\ge0$ such that
  $$ x_1^2+x_2^2+\dots+x_n^2\le n. $$

If a player cannot choose a suitable $x_n$, the game ends and the opponent wins; if the game continues forever, neither wins. All chosen numbers are known to both players.

The problem asks for which $\lambda$ Alice has a winning strategy, for which $\lambda$ Bazza has a winning strategy, and for which $\lambda$ neither can force a win (a draw). The complete solution, obtained in [{rkrw}] and [{zn8k}], is:

- **Bazza wins** for $\lambda<\dfrac{\sqrt2}{2}$,
- **Draw** for $\dfrac{\sqrt2}{2}\le\lambda\le1$,
- **Alice wins** for $\lambda>1$.

This elegant classification has inspired a wealth of generalizations, each exploring a different facet of the underlying structure. The present survey aims to give a unified account of these developments.

## 1. The original solution

Both proofs in [{rkrw}] and [{zn8k}] use slack variables. Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$. Define $A_n=\lambda n-S_n$ (Alice’s slack) and $B_n=n-Q_n$ (Bazza’s slack). Under the natural *greedy* strategy each player always takes the largest admissible number, i.e. makes her or his own slack zero. This leads to the recurrence

$$ s_{k+1}=2\lambda-\sqrt{2-s_k^{2}},\qquad s_1=\lambda, $$

where $s_k$ is a suitable slack variable. The game continues as long as $0\le s_k\le\sqrt2$. Analysing the fixed points of this recurrence yields the thresholds $\lambda=\sqrt2/2$ and $\lambda=1$.

A crucial step is the **monotonicity lemma**: any deviation from the greedy choice can only increase the opponent’s slack, hence cannot improve the player’s own prospects. Consequently greedy strategies are optimal, and the recurrence indeed captures the outcome under optimal play.

## 2. Computer‑verified components

Several authors have formalised parts of the solution in the Lean theorem prover, strengthening the reliability of the arguments.

- [{lxlv}] formalises the monotonicity lemmas for Alice and Bazza, providing a machine‑checked justification for the reduction to greedy play.
- [{araj}] verifies the key inequalities $s+\sqrt{2-s^{2}}\le2$ and $s+\sqrt{2-s^{2}}\ge\sqrt2$, and proves that for $\lambda>1$ the greedy sequence eventually exceeds $\sqrt2$ (Alice wins) while for $\lambda<\sqrt2/2$ it becomes negative (Bazza wins).

These formalisations offer a rigorous foundation for the analytic proofs.

## 3. Generalisation to $L^p$ constraints

A natural extension replaces the square‑sum constraint by an $L^p$ norm. In the **generalised inekoalaty game** Bazza must satisfy $\sum x_i^p\le n$ on even turns, while Alice’s constraint remains linear. The case $p>1$ was solved in [{lunq}]; the conjecture for $00$ is:

- If $p\ge1$: Bazza wins for $\lambda<2^{1/p-1}$, draw for $2^{1/p-1}\le\lambda\le1$, Alice wins for $\lambda>1$.
- If $p\le1$: Bazza wins for $\lambda<1$, draw for $1\le\lambda\le2^{1/p-1}$, Alice wins for $\lambda>2^{1/p-1}$.

The proof follows the same slack‑variable approach, using Jensen’s inequality to bound the function $s+(2-s^{p})^{1/p}$.

## 4. Swapped constraints

If the roles of the constraints are exchanged (Alice quadratic, Bazza linear) the recurrence is unchanged but the interpretation of the variable $s_k$ is different. As shown in [{1sm0}], the thresholds become

- Alice wins for $\lambda<\dfrac{\sqrt2}{2}$,
- Draw for $\dfrac{\sqrt2}{2}\le\lambda\le1$,
- Bazza wins for $\lambda>1$.

Thus the critical numbers $\sqrt2/2$ and $1$ remain the same, but the winning players are interchanged.

## 5. Asymmetric $L^p$ vs $L^q$ constraints

The most general **asymmetric** version allows different exponents for the two players. Alice is subject to an $L^q$ constraint ($\sum x_i^q\le\lambda^{q} n$) and Bazza to an $L^p$ constraint ($\sum x_i^p\le n$). This game was completely solved in [{mu6i}]. Let

$$ \lambda_c:=2^{1/p-1/q}. $$

Then

- Bazza wins for $\lambda<\min\{1,\lambda_c\}$,
- Alice wins for $\lambda>\max\{1,\lambda_c\}$,
- the game is a draw for $\min\{1,\lambda_c\}\le\lambda\le\max\{1,\lambda_c\}$.

This result unifies all previously known special cases:
- $(p,q)=(2,1)$ gives the original game,
- $(p,q)=(p,1)$ gives the symmetric $L^p$ game,
- $(p,q)=(1,2)$ gives the swapped game,
- $p=q$ gives the fully symmetric case where the only draw occurs at $\lambda=1$.

## 6. Power‑law growth of the right‑hand sides

Another direction generalises the right‑hand sides from linear to power‑law functions. In [{6y2s}] the constraints are

- Alice: $\sum x_i^p\le\lambda n^{\alpha}$,
- Bazza: $\sum x_i^q\le n^{\beta}$,

where $p,q,\alpha,\beta>0$. Under greedy play the game reduces to a non‑autonomous recurrence

$$ a_k^{p}= \lambda\bigl((2k-1)^{\alpha}-(2k-3)^{\alpha}\bigr)-b_{k-1}^{\,p},\qquad
   b_k^{q}= \bigl((2k)^{\beta}-(2k-2)^{\beta}\bigr)-a_k^{\,q}. $$

When $\alpha=\beta=1$ (autonomous case) draw regions exist for many pairs $(p,q)$. When $\alpha\neq\beta$ or $\alpha=\beta\neq1$ the draw region typically vanishes, and a single critical $\lambda_c(\alpha,\beta,p,q)$ separates Bazza’s winning region ($\lambda<\lambda_c$) from Alice’s winning region ($\lambda>\lambda_c$).

## 7. Scaling laws for power‑law growth

For the special case $\alpha=\beta=\gamma\neq1$ the critical $\lambda_c$ exhibits a scaling law. Numerical experiments reported in [{b1xz}] suggest

$$ \lambda_c\propto\gamma^{-\theta}, $$

with $\theta\approx\frac32$ for $p=1$, $q=2$, $\gamma>1$. For $p=q$ the critical value is $\lambda_c\approx1$ independently of $\gamma$, and for $\gamma<1$ the scaling changes sign. A heuristic asymptotic analysis using dominant‑balance arguments explains these observations.

## 8. Other variants

- **Linear‑quadratic game with parameters** [{knjh}]: constraints $\sum x_i\le\alpha n$, $\sum x_i^2\le\beta n$. The thresholds are $\alpha_c=\sqrt{2\beta}/2$ and $\alpha_u=\sqrt{\beta}$, with a draw between them.

- **Computer‑verified bounds for $p\ge1$** [{zdg7}]: a Lean formalisation of the inequalities $2^{1/p}\le s+(2-s^{p})^{1/p}\le2$ and the resulting linear growth/decay of the greedy sequence (the paper is currently under review).

## 9. Open problems

Despite the wealth of results, several interesting questions remain open.

1. **Rigorous scaling exponents.** Prove analytically the exponent $\theta=\frac32$ observed for $p=1$, $q=2$, $\gamma>1$.

2. **Stochastic versions.** Introduce randomness, e.g. allow players to choose distributions over moves, or let the constraints be satisfied only with a certain probability.

3. **Continuous‑time analogue.** Replace the discrete turns by a continuous time variable; the constraints become integral inequalities. Does the game still exhibit sharp thresholds?

4. **Multi‑player games.** Consider three or more players, each with a different $L^p$ constraint. Can the outcome be classified in a similar way?

5. **Varying exponents.** Study games where the exponents $p_n,q_n$ depend on the turn number $n$.

6. **Other norms.** Replace the $L^p$ norms by Orlicz norms or other Banach‑space norms.

7. **Computational complexity.** Determine the complexity of deciding the winner for given parameters when the players are not restricted to greedy strategies (the greedy‑optimality lemma only applies to the original form of the constraints).

8. **Lean formalisation of the full classification.** A complete computer‑verified proof of the asymmetric $L^p$ vs $L^q$ result would be a valuable contribution.

## Conclusion

The inekoalaty game has proven to be a remarkably fertile ground for mathematical exploration. Starting from a simple deterministic two‑player constraint game, it has spawned a rich family of generalizations, each revealing new aspects of the interplay between different growth constraints. The recurring themes—slack variables, greedy optimality, one‑dimensional recurrences, and the use of convexity/concavity inequalities—provide a unifying framework that makes the problem tractable while still yielding non‑trivial results.

The research community has produced a comprehensive body of work, ranging from computer‑verified lemmas to asymptotic scaling laws. This survey has attempted to gather these results in a single place, hoping to serve as a reference for newcomers and a stimulus for further investigations.

## Acknowledgements

We thank all authors of the cited publications for their contributions to this evolving story.

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{lxlv}] Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
- [{araj}] Computer‑verified recurrence analysis for the inekoalaty game.
- [{lunq}] Generalized Inekoalaty Game with $L^p$ Constraints.
- [{8nk6}] Generalized Inekoalaty Game with Exponent $p$: Thresholds and Conjectures.
- [{mxiv}] Complete Solution of the Generalized Inekoalaty Game for All Exponents $p>0$.
- [{1sm0}] Correct thresholds for the swapped inekoalaty game.
- [{mu6i}] Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints.
- [{6y2s}] Generalized Inekoalaty Games with Power‑Law Constraints.
- [{b1xz}] Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth (submitted).
- [{knjh}] Generalized Inekoalaty Game with Linear and Quadratic Constraints.
- [{vqh5}] The Inekoalaty Game and Its Generalizations: A Survey.
- [{olab}] A Complete Solution to the Inekoalaty Game and Open Problems.
- [{zdg7}] Computer‑verified bounds for the generalized inekoalaty game with $L^p$ constraints ($p\ge1$) (under review).

(reviews are hidden until publication/rejection)

reference=[f4z3]
title=The Inekoalaty Game: A Comprehensive Survey of Results and Generalizations
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]

exit_code: 1
duration_ms: 442
stdout:
```
p=3, q=2
s=0.000, φ=2.828427
s=0.200, φ=2.752000
s=0.400, φ=2.559897
s=0.600, φ=2.316225
s=0.800, φ=2.098019
s=1.000, φ=2.000000
s=1.200, φ=2.147066
s=1.400, φ=2.752000

```
stderr:
```
Traceback (most recent call last):
  File "/home/agent/phi_plot.py", line 13, in 
    print(f"s={s:.3f}, φ={val:.6f}")
                         ^^^^^^^^^
TypeError: unsupported format string passed to NoneType.__format__
```

exit_code: 0
duration_ms: 2178
stdout:
```

p=3, q=2
  lower threshold (Bazza → draw) ≈ 0.999969
  upper threshold (draw → Alice) ≈ 1.414215
  draw interval width = 0.414246
    λ=0.98997: Bazza
    λ=0.99997: Bazza
    λ=1.00997: Draw
    λ=1.40422: Draw
    λ=1.41422: Alice
    λ=1.42422: Alice

p=5, q=2
  lower threshold (Bazza → draw) ≈ 0.999969
  upper threshold (draw → Alice) ≈ 1.499969
  draw interval width = 0.500000
    λ=0.98997: Bazza
    λ=0.99997: Bazza
    λ=1.00997: Draw
    λ=1.48997: Draw
    λ=1.49997: Draw
    λ=1.50997: Draw

p=4, q=3
  lower threshold (Bazza → draw) ≈ 0.999969
  upper threshold (draw → Alice) ≈ 1.259918
  draw interval width = 0.259949
    λ=0.98997: Bazza
    λ=0.99997: Bazza
    λ=1.00997: Draw
    λ=1.24992: Draw
    λ=1.25992: Draw
    λ=1.26992: Alice

p=5, q=3
  lower threshold (Bazza → draw) ≈ 0.999969
  upper threshold (draw → Alice) ≈ 1.499969
  draw interval width = 0.500000
    λ=0.98997: Bazza
    λ=0.99997: Bazza
    λ=1.00997: Draw
    λ=1.48997: Draw
    λ=1.49997: Draw
    λ=1.50997: Draw

p=2, q=1.5
  lower threshold (Bazza → draw) ≈ 0.999969
  upper threshold (draw → Alice) ≈ 1.259918
  draw interval width = 0.259949
    λ=0.98997: Bazza
    λ=0.99997: Bazza
    λ=1.00997: Draw
    λ=1.24992: Draw
    λ=1.25992: Draw
    λ=1.26992: Alice

```
stderr:
```
```

exit_code: 0
duration_ms: 1190
stdout:
```

p=3, q=2
  λ_c ≈ 1.000011
  λ=0.99001: Bazza
  λ=1.00001: Draw
  λ=1.01001: Draw

p=5, q=2
  λ_c ≈ 1.000011
  λ=0.99001: Bazza
  λ=1.00001: Draw
  λ=1.01001: Draw

p=4, q=3
  λ_c ≈ 1.000011
  λ=0.99001: Bazza
  λ=1.00001: Draw
  λ=1.01001: Draw

p=5, q=3
  λ_c ≈ 1.000011
  λ=0.99001: Bazza
  λ=1.00001: Draw
  λ=1.01001: Draw

p=2, q=1.5
  λ_c ≈ 1.000011
  λ=0.99001: Bazza
  λ=1.00001: Draw
  λ=1.01001: Draw

```
stderr:
```
```

Review submitted for publication [mu6i].

exit_code: 0
duration_ms: 296
stdout:
```
Original game (p=2,q=1)
λ=0.50: Alice cannot move -> Bazza wins
λ=0.60: Alice cannot move -> Bazza wins
λ=0.70: Alice cannot move -> Bazza wins
λ=0.80: Draw
λ=0.90: Draw
λ=1.00: Draw
λ=1.10: Bazza cannot move -> Alice wins
λ=1.20: Bazza cannot move -> Alice wins
Predicted λ_c = 0.707107

Swapped game (p=1,q=2)
λ=0.50: Alice cannot move -> Bazza wins
λ=0.70: Alice cannot move -> Bazza wins
λ=0.90: Alice cannot move -> Bazza wins
λ=1.00: Draw
λ=1.10: Draw
λ=1.20: Draw
λ=1.30: Draw
λ=1.40: Draw
λ=1.50: Bazza cannot move -> Alice wins
Predicted λ_c = 1.414214
Expected Bazza wins for λ<1, draw for 1≤λ≤√2≈1.414, Alice wins for λ>√2

```
stderr:
```
```

reference=[mu6i]
title=Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints
author=vnir
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[asymmetric.tex]
abstract = We study a generalization of the two-player inekoalaty game where Alice's constraint is an $L^q$ norm and Bazza's constraint is an $L^p$ norm, with $p,q>0$. Using slack variables and greedy strategies, we reduce the game to a one-dimensional recurrence and prove a complete classification: let $\lambda_c=2^{1/p-1/q}$. Then Bazza has a winning strategy for $\lambda<\min(1,\lambda_c)$, Alice has a winning strategy for $\lambda>\max(1,\lambda_c)$, and the game is a draw for $\lambda$ between $\min(1,\lambda_c)$ and $\max(1,\lambda_c)$. The result unifies all previously known special cases and reveals a striking symmetry between the players.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{booktabs}
\usepackage{graphicx}
\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{definition}{Definition}

\title{Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We study a generalization of the two-player inekoalaty game where Alice's constraint is an $L^q$ norm and Bazza's constraint is an $L^p$ norm, with $p,q>0$. Using slack variables and greedy strategies, we reduce the game to a one-dimensional recurrence and prove a complete classification: let $\lambda_c=2^{1/p-1/q}$. Then Bazza has a winning strategy for $\lambda<\min(1,\lambda_c)$, Alice has a winning strategy for $\lambda>\max(1,\lambda_c)$, and the game is a draw for $\lambda$ between $\min(1,\lambda_c)$ and $\max(1,\lambda_c)$. The result unifies all previously known special cases and reveals a striking symmetry between the players.
\end{abstract}

\section{Introduction}

The inekoalaty game is a two-player perfect-information game introduced in earlier work [{rkrw},{zn8k}]. In its original form, Alice (moving on odd turns) must satisfy a linear constraint $\sum x_i\le\lambda n$, while Bazza (moving on even turns) must satisfy a quadratic constraint $\sum x_i^2\le n$. The parameter $\lambda>0$ determines the balance between the constraints. The game has been completely solved: Alice wins for $\lambda>1$, Bazza wins for $\lambda<1/\sqrt2$, and the game is a draw for $1/\sqrt2\le\lambda\le1$.

Several generalizations have been proposed. [{lunq}] replaced the quadratic constraint by an $L^p$ constraint with $p>1$, obtaining thresholds $\lambda_c=2^{1/p-1}$ and $\lambda=1$. [{8nk6}] extended the analysis to arbitrary $p>0$ and conjectured a classification that distinguishes between $p\ge1$ and $p\le1$.

In this paper we consider the most general asymmetric setting: Alice is subject to an $L^q$ constraint and Bazza to an $L^p$ constraint, where $p,q>0$ are arbitrary exponents. The game is defined as follows.

\subsection{The game}

Let $p,q>0$ be fixed exponents and $\lambda>0$ a parameter. Players Alice and Bazza alternate turns, with Alice moving on odd turns and Bazza on even turns. On turn $n$ the player whose turn it is chooses a number $x_n\ge0$ satisfying
\[
\begin{cases}
\displaystyle\sum_{i=1}^n x_i^{\,q}\le \lambda^{\,q}\, n & \text{if $n$ is odd (Alice),}\\[4mm]
\displaystyle\sum_{i=1}^n x_i^{\,p}\le n & \text{if $n$ is even (Bazza).}
\end{cases}
\]
If a player cannot choose a suitable $x_n$, the game ends and the other player wins. If the game continues forever, neither wins. All previous choices are known to both players.

The original game corresponds to $(p,q)=(2,1)$; the symmetric $L^p$ generalization corresponds to $q=1$.

\section{Slack variables and greedy strategies}

Define the slacks
\[
A_n=\lambda^{\,q}n-\sum_{i=1}^n x_i^{\,q},\qquad
B_n=n-\sum_{i=1}^n x_i^{\,p}.
\]
After each turn the slacks evolve as
\[
A_n=A_{n-1}+\lambda^{\,q}-x_n^{\,q},\qquad
B_n=B_{n-1}+1-x_n^{\,p},
\]
with the requirement that $A_n\ge0$ after Alice's moves and $B_n\ge0$ after Bazza's moves.

A \emph{greedy} strategy for a player consists in choosing the largest admissible number, i.e.\ making the corresponding slack exactly zero. Thus
\[
\text{Alice (odd $n$)}:\; x_n=(A_{n-1}+\lambda^{\,q})^{1/q},\qquad
\text{Bazza (even $n$)}:\; x_n=(B_{n-1}+1)^{1/p}.
\]

The following monotonicity lemma, proved in [{lxlv}] for $p=2$, $q=1$, extends without change to arbitrary $p,q>0$.

\begin{lemma}[Monotonicity]
For any state $(A_{n-1},B_{n-1})$ and any admissible choice $x_n$,
\begin{enumerate}
\item If it is Alice's turn and $x_n^{\,q}\le A_{n-1}+\lambda^{\,q}$, then the resulting state satisfies $A_n\ge0$ and $B_n\ge B_n^{\mathrm{gr}}$, where $B_n^{\mathrm{gr}}$ is the slack obtained after the greedy choice.
\item If it is Bazza's turn and $x_n^{\,p}\le B_{n-1}+1$, then the resulting state satisfies $B_n\ge0$ and $A_n\ge A_n^{\mathrm{gr}}$, where $A_n^{\mathrm{gr}}$ is the slack obtained after the greedy choice.
\end{enumerate}
\end{lemma}
\begin{proof}
Choosing a smaller $x_n$ increases the player's own slack (which is harmless) and, because the functions $x\mapsto x^q$, $x\mapsto x^p$ are increasing, it also increases (or does not decrease) the opponent's slack.
\end{proof}

Consequently, if a player can guarantee a win (or a draw) by using the greedy strategy, then no deviation can prevent that outcome. Hence we may restrict attention to greedy play when searching for winning strategies.

\section{Reduction to a recurrence}

Assume both players follow their greedy strategies. Let $a_k=A_{2k}$ be Alice's slack after Bazza's $k$‑th move and $b_k=B_{2k-1}$ be Bazza's slack after Alice's $k$‑th move. A direct calculation gives
\[
b_k = 1-(a_{k-1}+\lambda^{\,q})^{p/q},\qquad
a_k = \lambda^{\,q}-\bigl(2-(a_{k-1}+\lambda^{\,q})^{p/q}\bigr)^{\,q/p}.
\]

Introduce $s_k=a_{k-1}+\lambda^{\,q}$ (so $s_1=\lambda^{\,q}$). Then the dynamics are described by the one‑dimensional recurrence
\begin{equation}\label{eq:rec}
s_{k+1}=2\lambda^{\,q}-\bigl(2-s_k^{\,p/q}\bigr)^{\,q/p},\qquad k\ge1.
\end{equation}
The game continues as long as $s_k\ge0$ (so that Alice can move) and $s_k^{\,p/q}\le2$ (so that Bazza can move). If $s_k<0$ then Alice loses; if $s_k^{\,p/q}>2$ then Bazza loses.

\section{Analysis of the recurrence}

Define the function
\[
f(s)=s+\bigl(2-s^{\,p/q}\bigr)^{\,q/p},\qquad 0\le s\le 2^{\,q/p}.
\]

A fixed point of (\ref{eq:rec}) satisfies $f(s)=2\lambda^{\,q}$.

The key observation is the behaviour of $f$, which depends on the ratio $q/p$. By the monotonicity of $L^r$ norms (or by Jensen's inequality) we have
\[
f(s)\begin{cases}
\le 2 & \text{if } q\le p,\\[2mm]
\ge 2 & \text{if } q\ge p .
\end{cases}
\]

Moreover, $f(0)=f(2^{\,q/p})=2^{\,q/p}$, while the extremum (minimum for $q>p$, maximum for $q\max\{1,\lambda_c\}$ then $2\lambda^{\,q}>f(s)$ for all $s$, the sequence $(s_k)$ is strictly increasing and eventually exceeds $2^{\,q/p}$; consequently $s_k^{\,p/q}>2$ and \emph{Bazza loses} (Alice wins).

\section{Main result}

\begin{theorem}\label{thm:main}
For the asymmetric inekoalaty game with exponents $p,q>0$ and parameter $\lambda>0$, let $\lambda_c:=2^{1/p-1/q}$. Under optimal play (which is greedy for both players) we have
\begin{enumerate}
\item Bazza has a winning strategy iff $\lambda<\min\{1,\lambda_c\}$.
\item Alice has a winning strategy iff $\lambda>\max\{1,\lambda_c\}$.
\item For $\min\{1,\lambda_c\}\le\lambda\le\max\{1,\lambda_c\}$ neither player has a winning strategy; both can force at least a draw.
\end{enumerate}
\end{theorem}

\begin{proof}
The monotonicity lemma justifies the restriction to greedy strategies. The recurrence (\ref{eq:rec}) describes the greedy dynamics, and the analysis above shows that the outcome depends on the position of $\\lambda$ relative to $1$ and $\\lambda_c$ exactly as stated.
\end{proof}

\section{Special cases}

\begin{itemize}
\item \textbf{Original game} $(p,q)=(2,1)$: $\lambda_c=2^{1/2-1}=1/\sqrt2$. We recover the known thresholds.
\item \textbf{Symmetric $L^p$ game} $(p,q)=(p,1)$: $\lambda_c=2^{1/p-1}$, matching the result of [{lunq}].
\item \textbf{Fully symmetric case} $p=q$: $\lambda_c=2^{1/p-1/p}=1$. Then Bazza wins for $\lambda<1$, Alice wins for $\lambda>1$, and the game is a draw only at $\lambda=1$.
\item \textbf{Reversed exponents} $(p,q)=(1,2)$: $\lambda_c=2^{1-1/2}=\sqrt2$. Hence Bazza wins for $\lambda<1$, draw for $1\le\lambda\le\sqrt2$, Alice wins for $\lambda>\sqrt2$.
\end{itemize}

Table~\ref{tab:examples} lists a few illustrative values.

\begin{table}[ht]
\centering
\caption{Thresholds $\lambda_c$ for various $(p,q)$.}
\label{tab:examples}
\begin{tabular}{ccccl}
\toprule
$p$ & $q$ & $\lambda_c$ & interpretation \\ \midrule
2 & 1 & $1/\sqrt2\approx0.7071$ & original game \\
3 & 1 & $2^{-2/3}\approx0.6300$ & Bazza's constraint stricter ($p>q$) \\
2 & 2 & $1$ & symmetric constraints \\
0.5 & 1 & $2^{2-1}=2$ & Bazza's constraint weaker ($p0$.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

reference=[mu6i]
title=Asymmetric Inekoalaty Game with $L^p$ vs $L^q$ Constraints
author=vnir
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[asymmetric.tex]

exit_code: 0
duration_ms: 357
stdout:
```
import Mathlib.Data.Real.Sqrt
import Mathlib.Tactic

open Real

lemma sqrt_two_sub_sq_add_x_le_two (x : ℝ) (hx : 0 ≤ x) (hx2 : x^2 ≤ 2) :
    Real.sqrt (2 - x^2) + x ≤ 2 := by
  have hpos : 0 ≤ Real.sqrt (2 - x^2) := Real.sqrt_nonneg _
  have hsq : (Real.sqrt (2 - x^2)) ^ 2 = 2 - x^2 :=
    Real.sq_sqrt (by nlinarith)
  have hprod : x * Real.sqrt (2 - x^2) ≤ 1 := by
    have hprod_sq : (x * Real.sqrt (2 - x^2)) ^ 2 ≤ 1 := by
      calc
        (x * Real.sqrt (2 - x^2)) ^ 2 = x^2 * ((Real.sqrt (2 - x^2)) ^ 2) := by ring
        _ = x^2 * (2 - x^2) := by rw [hsq]
        _ = 2 * x^2 - x^4 := by ring
        _ ≤ 1 := by
          have : (x^2 - 1)^2 ≥ 0 := pow_two_nonneg _
          nlinarith
    have hprod_nonneg : 0 ≤ x * Real.sqrt (2 - x^2) :=
      mul_nonneg hx hpos
    nlinarith
  have hsum_sq : (Real.sqrt (2 - x^2) + x)^2 ≤ 4 := by
    nlinarith
  nlinarith [sq_nonneg (Real.sqrt (2 - x^2) + x)]

#check sqrt_two_sub_sq_add_x_le_two

```
stderr:
```
```

exit_code: 0
duration_ms: 253
stdout:
```
total 80
drwxr-xr-x 1 agent agent 4096 Jan 10 07:42 .
drwxr-x--- 1 agent agent 4096 Jan 10 11:48 ..
drwxr-xr-x 7 agent agent 4096 Jan 10 07:10 .git
drwxr-xr-x 3 agent agent 4096 Jan 10 07:10 .github
-rw-r--r-- 1 agent agent    7 Jan 10 07:10 .gitignore
drwxr-xr-x 1 agent agent 4096 Jan 10 07:42 .lake
-rw-r--r-- 1 agent agent   68 Jan 10 07:10 Main.lean
drwxr-xr-x 1 agent agent 4096 Jan 10 07:32 Math
-rw-r--r-- 1 agent agent  143 Jan 10 07:10 Math.lean
-rw-r--r-- 1 agent agent    6 Jan 10 07:10 README.md
-rw-r--r-- 1 agent agent  110 Jan 10 07:10 lake-manifest.json
-rw-r--r-- 1 agent agent  232 Jan 10 07:42 lakefile.toml
-rw-r--r-- 1 agent agent  128 Jan 10 07:42 lakefile.toml.backup
-rw-r--r-- 1 agent agent   29 Jan 10 07:10 lean-toolchain
-rw-r--r-- 1 agent agent 1053 Jan 10 07:33 test.lean
-rw-r--r-- 1 agent agent  970 Jan 10 07:35 test_ineq.lean
-rw-r--r-- 1 agent agent   17 Jan 10 07:38 test_real.lean
-rw-r--r-- 1 agent agent   51 Jan 10 07:35 test_sqrt.lean

```
stderr:
```
```

Review submitted for publication [zdg7].

exit_code: 0
duration_ms: 290
stdout:
```
import Mathlib.Analysis.Convex.Function
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Real.Basic
import Mathlib.Tactic

open Real
open Set

section Inequalities

variable (p : ℝ) (hp : p ≥ 1)

-- Lower bound: for a,b ≥ 0, (a + b)^p ≥ a^p + b^p
lemma pow_sum_le_sum_pow (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) :
    (a + b) ^ p ≥ a ^ p + b ^ p := by
  have h : ConvexOn ℝ (Set.Ici 0) (fun x : ℝ => x ^ p) := convexOn_rpow hp (by linarith)
  have : (a + b) ^ p = 2 ^ p * (((a + b) / 2) ^ p) := by
    field_simp; ring
  -- Not straightforward. Let's use the inequality (a+b)^p ≥ 2^{p-1} (a^p + b^p)
  have : (a + b) ^ p ≥ 2^(p-1) * (a ^ p + b ^ p) := by
    have := convexOn_rpow hp (by linarith)
    -- Use Jensen with weights 1/2 each
    have := this.2 ha hb (by norm_num) (by norm_num) (by norm_num)
    calc
      (a + b) ^ p = 2 ^ p * (((a + b) / 2) ^ p) := by ring
      _ ≥ 2 ^ p * ((a ^ p + b ^ p) / 2) := by nlinarith
      _ = 2^(p-1) * (a ^ p + b ^ p) := by ring
  have : 2^(p-1) ≥ 1 := by
    refine rpow_le_rpow_of_exponent_le (by norm_num) (by linarith)
  nlinarith

-- Upper bound: a + b ≤ 2 * ((a^p + b^p)/2)^{1/p}
lemma sum_le_two_pow_mean (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) :
    a + b ≤ 2 * (((a ^ p + b ^ p) / 2) ^ (1 / p)) := by
  have h : ConvexOn ℝ (Set.Ici 0) (fun x : ℝ => x ^ p) := convexOn_rpow hp (by linarith)
  have : ((a + b) / 2) ^ p ≤ (a ^ p + b ^ p) / 2 :=
    h.2 ha hb (by norm_num) (by norm_num) (by norm_num)
  have hdiv : 0 ≤ (a ^ p + b ^ p) / 2 := by nlinarith
  calc
    a + b = 2 * ((a + b) / 2) := by ring
    _ ≤ 2 * (((a ^ p + b ^ p) / 2) ^ (1 / p)) := by
      refine mul_le_mul_of_nonneg_left ?_ (by norm_num)
      exact (rpow_le_rpow (div_nonneg (by linarith) (by norm_num)) (by linarith) (by linarith)).mp this

-- Specialize to the case where a^p + b^p = 2.
lemma bounds_for_sum_eq_two (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a ^ p + b ^ p = 2) :
    2 ^ (1 / p) ≤ a + b ∧ a + b ≤ 2 := by
  constructor
  · have := pow_sum_le_sum_pow p hp a b ha hb
    rw [hab] at this
    have : (a + b) ^ p ≥ 2 := this
    exact (rpow_le_rpow (by linarith) (by linarith) hp).mp this
  · have := sum_le_two_pow_mean p hp a b ha hb
    rw [hab] at this
    simpa using this

end Inequalities

section Recurrence

variable (λ : ℝ) (p : ℝ) (hp : p ≥ 1)

-- Domain: s^p ≤ 2
def domain (s : ℝ) : Prop := s ^ p ≤ 2

-- The function f(s) = 2λ - (2 - s^p)^{1/p}
def f (s : ℝ) : ℝ := 2 * λ - ((2 : ℝ) - s ^ p) ^ (1 / p)

lemma f_domain {s : ℝ} (hs : domain p s) : domain p (f λ p s) := by
  dsimp [domain, f] at hs ⊢
  have h : (2 : ℝ) - s ^ p ≥ 0 := by linarith
  have hpow : (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = (2 : ℝ) - s ^ p := by
    rw [← rpow_mul h, div_mul_cancel (1 : ℝ) (ne_of_gt (by linarith [hp])), rpow_one]
  nlinarith

-- Sequence s₀ = λ, s_{k+1} = f(s_k)
noncomputable def s_seq : ℕ → ℝ
  | 0 => λ
  | n + 1 => f λ p (s_seq n)

lemma s_seq_domain (hλ_dom : domain p λ) : ∀ n, domain p (s_seq λ p n)
  | 0 => hλ_dom
  | n + 1 => f_domain λ p hp (s_seq_domain hλ_dom n)

-- Key inequality: for s in domain, 2λ - (2 - s^p)^{1/p) - s has sign opposite to s - s_star
-- We need the fixed point s_star satisfying s_star + (2 - s_star^p)^{1/p} = 2λ.
-- For λ ∈ [2^{1/p-1}, 1] there exists such a fixed point.
-- We'll assume existence for now.
axiom exists_fixed_point (hλ_low : (2 : ℝ) ^ (1 / p - 1) ≤ λ) (hλ_high : λ ≤ 1) :
    ∃ s, domain p s ∧ s + ((2 : ℝ) - s ^ p) ^ (1 / p) = 2 * λ ∧ 0 ≤ s ∧ s ≤ (2 : ℝ) ^ (1 / p)

noncomputable def s_star (hλ_low : (2 : ℝ) ^ (1 / p - 1) ≤ λ) (hλ_high : λ ≤ 1) : ℝ :=
  Classical.choose (exists_fixed_point λ p hp hλ_low hλ_high)

lemma s_star_properties (hλ_low : (2 : ℝ) ^ (1 / p - 1) ≤ λ) (hλ_high : λ ≤ 1) :
    let s := s_star λ p hp hλ_low hλ_high
    domain p s ∧ s + ((2 : ℝ) - s ^ p) ^ (1 / p) = 2 * λ ∧ 0 ≤ s ∧ s ≤ (2 : ℝ) ^ (1 / p) :=
  Classical.choose_spec (exists_fixed_point λ p hp hλ_low hλ_high)

-- Theorem: if λ > 1, then s_seq eventually exceeds (2)^{1/p}
theorem eventually_s_seq_exceeds (hλ_gt : λ > 1) (hλ_dom : domain p λ) :
    ∃ N, (s_seq λ p N) ^ p > 2 := by
  -- Similar to p=2 case: f(s) - s ≥ 2(λ - 1) > 0
  have : ∀ s, domain p s → f λ p s - s ≥ 2 * (λ - 1) := by
    intro s hs
    dsimp [f]
    have := bounds_for_sum_eq_two p hp s (((2 : ℝ) - s ^ p) ^ (1 / p)) (by linarith [hs])
      (by positivity) (by
        have : s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = 2 := by
          have h : (2 : ℝ) - s ^ p ≥ 0 := by linarith
          calc
            s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = s ^ p + ((2 : ℝ) - s ^ p) := by
              rw [← rpow_mul h, div_mul_cancel (1 : ℝ) (ne_of_gt (by linarith [hp])), rpow_one]
            _ = 2 := by linarith
        exact this)
    rcases this with ⟨h_low, h_up⟩
    linarith
  have : ∀ n, s_seq λ p n ≥ λ + 2 * (λ - 1) * n := by
    intro n
    induction' n with k IH
    · simp [s_seq]
    · have hdom : domain p (s_seq λ p k) := s_seq_domain λ p hp hλ_dom k
      have incr : f λ p (s_seq λ p k) ≥ s_seq λ p k + 2 * (λ - 1) := this (s_seq λ p k) hdom
      calc
        s_seq λ p (k + 1) = f λ p (s_seq λ p k) := rfl
        _ ≥ s_seq λ p k + 2 * (λ - 1) := incr
        _ ≥ (λ + 2 * (λ - 1) * k) + 2 * (λ - 1) := by linarith
        _ = λ + 2 * (λ - 1) * (k + 1) := by ring
  have : ∃ N, λ + 2 * (λ - 1) * (N : ℝ) > (2 : ℝ) ^ (1 / p) := by
    have : (2 : ℝ) ^ (1 / p) ≤ 2 := by
      refine rpow_le_rpow_of_exponent_ge (by norm_num) (by norm_num) (by linarith [hp])
    have : 2 * (λ - 1) > 0 := by linarith
    refine exists_nat_gt (((2 : ℝ) ^ (1 / p) - λ) / (2 * (λ - 1))) |>.imp fun N hN => ?_
    linarith
  rcases this with ⟨N, hN⟩
  refine ⟨N, ?_⟩
  have := this N
  have : s_seq λ p N > (2 : ℝ) ^ (1 / p) := by linarith
  exact (rpow_lt_rpow (by linarith) (by linarith) hp).mp this

-- Theorem: if λ < 2^{1/p-1}, then s_seq eventually becomes negative
theorem eventually_s_seq_negative (hλ_lt : λ < (2 : ℝ) ^ (1 / p - 1)) (hλ_nonneg : 0 ≤ λ) :
    ∃ N, s_seq λ p N < 0 := by
  have : (2 : ℝ) ^ (1 / p - 1) ≤ 1 := by
    refine rpow_le_rpow_of_exponent_ge (by norm_num) (by norm_num) (by linarith [hp])
  have : λ < 1 := by linarith
  have : ∀ s, domain p s → 0 ≤ s → f λ p s - s ≤ 2 * λ - 2 ^ (1 / p) := by
    intro s hs hs_nonneg
    dsimp [f]
    have := bounds_for_sum_eq_two p hp s (((2 : ℝ) - s ^ p) ^ (1 / p)) hs_nonneg
      (by positivity) (by
        have : s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = 2 := by
          have h : (2 : ℝ) - s ^ p ≥ 0 := by linarith
          calc
            s ^ p + (((2 : ℝ) - s ^ p) ^ (1 / p)) ^ p = s ^ p + ((2 : ℝ) - s ^ p) := by
              rw [← rpow_mul h, div_mul_cancel (1 : ℝ) (ne_of_gt (by linarith [hp])), rpow_one]
            _ = 2 := by linarith
        exact this)
    rcases this with ⟨h_low, h_up⟩
    linarith
  have : 2 * λ - 2 ^ (1 / p) < 0 := by
    have : 2 ^ (1 / p) > 2 * λ := by
      calc
        2 ^ (1 / p) > 2 * (2 ^ (1 / p - 1)) := by
          have : 2 ^ (1 / p) = 2 * 2 ^ (1 / p - 1) := by
            rw [rpow_sub (by norm_num) (by linarith [hp])]
          linarith
        _ > 2 * λ := by nlinarith
    linarith
  have : ∀ n, s_seq λ p n ≤ λ + (2 * λ - 2 ^ (1 / p)) * n := by
    intro n
    induction' n with k IH
    · simp [s_seq]
    · have hdom : domain p (s_seq λ p k) := s_seq_domain λ p hp (by linarith [hλ_nonneg]) k
      have hnonneg : 0 ≤ s_seq λ p k := by
        have : (s_seq λ p k) ^ p ≤ 2 := hdom
        exact (rpow_nonneg_of_nonneg (by linarith) p).mp this
      have decr : f λ p (s_seq λ p k) ≤ s_seq λ p k + (2 * λ - 2 ^ (1 / p)) :=
        this (s_seq λ p k) hdom hnonneg
      calc
        s_seq λ p (k + 1) = f λ p (s_seq λ p k) := rfl
        _ ≤ s_seq λ p k + (2 * λ - 2 ^ (1 / p)) := decr
        _ ≤ (λ + (2 * λ - 2 ^ (1 / p)) * k) + (2 * λ - 2 ^ (1 / p)) := by linarith
        _ = λ + (2 * λ - 2 ^ (1 / p)) * (k + 1) := by ring
  have : ∃ N, λ + (2 * λ - 2 ^ (1 / p)) * (N : ℝ) < 0 := by
    have : 2 * λ - 2 ^ (1 / p) < 0 := by linarith
    refine exists_nat_gt ((-λ) / (2 * λ - 2 ^ (1 / p))) |>.imp fun N hN => ?_
    linarith
  rcases this with ⟨N, hN⟩
  exact ⟨N, by linarith [this N]⟩

end Recurrence

```
stderr:
```
```

Attachment downloaded to /home/agent/publications/zdg7.

reference=[zdg7]
title=Computer-verified bounds for the generalized inekoalaty game with L^p constraints (p ≥ 1)
author=fi8r
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[GeneralizedInekoalaty.lean]
abstract = We formalize in Lean the key inequalities for the generalized inekoalaty game where Bazza’s constraint is an $L^p$ norm with $p\ge1$. Using convexity of $x\mapsto x^p$, we prove $2^{1/p}\le s+(2-s^p)^{1/p}\le2$ for $0\le s^p\le2$. From these bounds we derive the thresholds $\lambda_c(p)=2^{1/p-1}$ and $\lambda=1$: Bazza wins for $\lambda<\lambda_c(p)$, the game is a draw for $\lambda_c(p)\le\lambda\le1$, and Alice wins for $\lambda>1$. The attached Lean code verifies the inequalities and the linear growth/decay of the greedy sequence, providing a rigorous foundation for the results of [{lunq}] and [{mxiv}].

# Computer-verified bounds for the generalized inekoalaty game with $L^p$ constraints ($p\ge1$)

## Introduction

The inekoalaty game is a two‑player alternating‑move game with parameter $\lambda>0$. In the generalized version [{lunq}] Bazza’s constraint involves an arbitrary exponent $p>0$: on even turns he must satisfy $\sum x_i^p\le n$, while Alice’s constraint remains linear ($\sum x_i\le\lambda n$). For $p\ge1$ the problem is completely solved: Bazza wins for $\lambda<2^{1/p-1}$, the game is a draw for $2^{1/p-1}\le\lambda\le1$, and Alice wins for $\lambda>1$ [{lunq}]. A unified proof for all $p>0$ has recently been given in [{mxiv}].

In this note we present a computer‑verified (Lean) proof of the fundamental inequalities and the recurrence analysis for $p\ge1$. The attached file `GeneralizedInekoalaty.lean` contains all definitions, lemmas and theorems described below.

## Key inequalities

Let $p\ge1$ and $a\ge0$ with $a^p\le2$. Define $b=(2-a^p)^{1/p}$. Using the convexity of $x\mapsto x^p$ on $[0,\infty)$ we obtain the two‑sided bound

\[
2^{1/p}\;\le\;a+b\;\le\;2 .
\tag{1}
\]

The lower bound follows from the inequality $(a+b)^p\ge a^p+b^p=2$, which itself is a consequence of convexity and the fact that $2^{p-1}\ge1$. The upper bound is Jensen’s inequality applied to the convex function $x^p$:

\[
\Bigl(\frac{a+b}{2}\Bigr)^{\!p}\le\frac{a^p+b^p}{2}=1,
\]

hence $(a+b)/2\le1$, i.e. $a+b\le2$.

Both inequalities are formalised in Lean as

```lean
lemma bounds_for_sum_eq_two (a b : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a ^ p + b ^ p = 2) :
    2 ^ (1 / p) ≤ a + b ∧ a + b ≤ 2 := ...
```

## The recurrence under greedy play

Assume both players adopt greedy strategies (each always takes the largest admissible number). Let $s_k$ denote Alice’s $k$‑th move (after scaling). The greedy dynamics reduce to the one‑dimensional recurrence

\[
s_{k+1}=2\lambda-(2-s_k^{\,p})^{1/p},\qquad s_1=\lambda .
\tag{2}
\]

The game continues as long as $s_k\ge0$ and $s_k^{\,p}\le2$; if $s_k<0$ Alice loses, if $s_k^{\,p}>2$ Bazza loses.

Define the map $f(s)=2\lambda-(2-s^{\,p})^{1/p}$. Using (1) we obtain the linear estimates

\[
f(s)-s\ge2(\lambda-1)\qquad (\lambda>1),
\]
\[
f(s)-s\le2\lambda-2^{1/p}\qquad (\lambda<2^{1/p-1}).
\]

These estimates are proved in Lean and imply the following behaviour.

## Winning thresholds

**Theorem 1 (Alice wins).** If $\lambda>1$ and $\lambda^{\,p}\le2$, then there exists $N$ such that $s_N^{\,p}>2$; consequently Bazza cannot move and Alice wins.

*Proof.* From $f(s)-s\ge2(\lambda-1)>0$ we obtain $s_k\ge\lambda+2(\lambda-1)k$. For sufficiently large $k$ this exceeds $2^{1/p}$, hence $s_k^{\,p}>2$. ∎

**Theorem 2 (Bazza wins).** If $0\le\lambda<2^{1/p-1}$, then there exists $N$ such that $s_N<0$; thus Alice cannot move and Bazza wins.

*Proof.* Now $f(s)-s\le2\lambda-2^{1/p}<0$, giving $s_k\le\lambda+(2\lambda-2^{1/p})k$, which becomes negative for large $k$. ∎

**Draw region.** For $2^{1/p-1}\le\lambda\le1$ the recurrence admits a fixed point $s^*$ satisfying $s^*+(2-(s^*)^p)^{1/p}=2\lambda$. One can show that the sequence $(s_k)$ converges to $s^*$; hence both constraints can be satisfied indefinitely and neither player can force a win. (The existence of the fixed point follows from the intermediate value theorem applied to the continuous function $h(s)=s+(2-s^{\,p})^{1/p}$ on $[0,2^{1/p}]$; a formal proof of this step is not yet included in the Lean code.)

The Lean formalisation provides the precise statements and proofs of Theorems 1 and 2.

```lean
theorem eventually_s_seq_exceeds (hλ_gt : λ > 1) (hλ_dom : domain p λ) :
    ∃ N, (s_seq λ p N) ^ p > 2 := ...

theorem eventually_s_seq_negative (hλ_lt : λ < (2 : ℝ) ^ (1 / p - 1)) (hλ_nonneg : 0 ≤ λ) :
    ∃ N, s_seq λ p N < 0 := ...
```

## Discussion

The computer‑verified proofs confirm the analytic results of [{lunq}] for $p\ge1$. The inequalities (1) are the only non‑trivial ingredient; they are derived directly from the convexity of the power function, avoiding ad‑hoc manipulations.

The Lean code can be compiled with mathlib4 and serves as a rigorous foundation for the threshold results. It also provides a template for formalising further variants of the game (e.g. different exponents for the two players, non‑autonomous right‑hand sides, etc.).

## Open points

- A complete formalisation of the draw region requires proving the existence of a fixed point of (2) for $2^{1/p-1}\le\lambda\le1$ (via the intermediate value theorem).
- Extending the analysis to $p<1$ would require analogous inequalities based on concavity; this can be done using `concaveOn_rpow` from mathlib and is left for future work.

## Conclusion

We have presented a computer‑verified proof of the key inequalities and the recurrence analysis for the generalized inekoalaty game with exponent $p\ge1$. The work strengthens the existing theoretical results by providing machine‑checked proofs of the crucial estimates and the linear growth/decay of the greedy sequence.

## References

- [{lunq}] Generalized Inekoalaty Game with $L^p$ Constraints.
- [{mxiv}] Complete Solution of the Generalized Inekoalaty Game for All Exponents $p>0$.
- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{lxlv}] Optimality of greedy strategies in the inekoalaty game: a Lean formalization.

(reviews are hidden until publication/rejection)

reference=[zdg7]
title=Computer-verified bounds for the generalized inekoalaty game with L^p constraints (p ≥ 1)
author=fi8r
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[GeneralizedInekoalaty.lean]

Review submitted for publication [mxiv].

exit_code: 0
duration_ms: 283
stdout:
```
import math

def iterate(lmbda, p, n_iter=200):
    s = lmbda
    for i in range(n_iter):
        if s**p > 2:
            return 'Bazza loses', i, s
        s_next = 2*lmbda - (2 - s**p)**(1/p)
        if s_next < 0:
            return 'Alice loses', i, s_next
        s = s_next
    return 'Continue', n_iter, s

def find_thresholds(p):
    # find lower threshold where Alice loses -> draw
    lower = None
    upper = None
    # coarse scan
    for l in [i*0.01 for i in range(1, 2000)]:
        res, it, val = iterate(l, p, 300)
        if res == 'Alice loses':
            lower = l
        elif res == 'Continue' and lower is not None and upper is None:
            # transition
            print(f"Possible lower threshold around {lower} -> {l}")
            # refine
            low = lower
            high = l
            for _ in range(30):
                mid = (low+high)/2
                res2, _, _ = iterate(mid, p, 300)
                if res2 == 'Alice loses':
                    low = mid
                else:
                    high = mid
            lower_th = (low+high)/2
            print(f"  refined: {lower_th}")
            break
    # find upper threshold where draw -> Bazza loses
    for l in [i*0.01 for i in range(1, 2000)]:
        res, it, val = iterate(l, p, 300)
        if res == 'Continue':
            upper = l
        elif res == 'Bazza loses' and upper is not None:
            print(f"Possible upper threshold around {upper} -> {l}")
            low = upper
            high = l
            for _ in range(30):
                mid = (low+high)/2
                res2, _, _ = iterate(mid, p, 300)
                if res2 == 'Continue':
                    low = mid
                else:
                    high = mid
            upper_th = (low+high)/2
            print(f"  refined: {upper_th}")
            break
    return lower_th, upper_th

for p in [0.25, 0.5, 0.75, 0.9, 1.0, 1.5, 2.0]:
    print(f"\np = {p}")
    lower, upper = find_thresholds(p)
    print(f"Lower threshold (Alice loses -> draw): {lower}")
    print(f"Upper threshold (draw -> Bazza loses): {upper}")
    if p < 1:
        conjectured_lower = 1.0
        conjectured_upper = 2**(1/p - 1)
    else:
        conjectured_lower = 2**(1/p - 1)
        conjectured_upper = 1.0
    print(f"Conjectured: lower={conjectured_lower}, upper={conjectured_upper}")

```
stderr:
```
```

exit_code: 0
duration_ms: 225
stdout:
```
total 24
drwxr-xr-x 2 agent agent 4096 Jan 10 11:48 .
drwxr-xr-x 5 agent agent 4096 Jan 10 11:48 ..
-rw-r--r-- 1 agent agent 2375 Jan 10 11:48 analyze_p_less_1_simple.py
-rw-r--r-- 1 agent agent 9392 Jan 10 11:48 complete_proof.tex

```
stderr:
```
```

Attachment downloaded to /home/agent/publications/mxiv.

exit_code: 0
duration_ms: 972
stdout:
```
s=0.00, H=4.000000
s=0.50, H=2.171573
s=1.00, H=2.000000
s=1.50, H=2.101021
s=2.00, H=2.343146
s=3.00, H=3.071797
s=4.00, H=4.000000

```
stderr:
```
```

reference=[mxiv]
title=Complete Solution of the Generalized Inekoalaty Game for All Exponents p>0
author=slsx
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[analyze_p_less_1_simple.py,complete_proof.tex]
abstract = We present a unified proof of the winning thresholds for the generalized inekoalaty game with exponent $p>0$, where Alice is constrained by a linear sum and Bazza by a sum of $p$-th powers. For $p\ge1$ we recover the result of [{lunq}]; for $p<1$ we prove the conjecture stated in [{8nk6}]. The proof uses slack variables, greedy strategies, and Jensen's inequality for the power function $x\mapsto x^p$. The thresholds are $\lambda_c(p)=2^{1/p-1}$ and $\lambda_u(p)=1$ for $p\ge1$, and $\lambda_c(p)=1$, $\lambda_u(p)=2^{1/p-1}$ for $p\le1$. Between these thresholds the game is a draw; outside them Bazza (respectively Alice) has a winning strategy.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{booktabs}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{definition}{Definition}

\title{Complete Solution of the Generalized Inekoalaty Game for All Exponents $p>0$}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We present a unified proof of the winning thresholds for the generalized inekoalaty game with exponent $p>0$, where Alice is constrained by a linear sum and Bazza by a sum of $p$-th powers. For $p\ge1$ we recover the result of [{lunq}]; for $p<1$ we prove the conjecture stated in [{8nk6}]. The proof uses slack variables, greedy strategies, and Jensen's inequality for the power function $x\mapsto x^p$. The thresholds are $\lambda_c(p)=2^{1/p-1}$ and $\lambda_u(p)=1$ for $p\ge1$, and $\lambda_c(p)=1$, $\lambda_u(p)=2^{1/p-1}$ for $p\le1$. Between these thresholds the game is a draw; outside them Bazza (respectively Alice) has a winning strategy.
\end{abstract}

\section{Introduction}

The inekoalaty game is a two-player perfect-information game introduced in [{zn8k}]. In its generalized form, the parameter $\lambda>0$ and an exponent $p>0$ are given. Players Alice and Bazza alternate turns, with Alice moving on odd turns and Bazza on even turns. On turn $n$ the moving player chooses a number $x_n\ge0$ subject to
\begin{align*}
\text{odd }n &: x_1+x_2+\dots+x_n\le\lambda n,\\[2mm]
\text{even }n &: x_1^p+x_2^p+\dots+x_n^p\le n .
\end{align*}
If a player cannot choose a suitable $x_n$, the game ends and the opponent wins; if the game continues forever, neither wins.

The original game ($p=2$) was solved in [{zn8k}]; the thresholds are $\lambda=\sqrt2/2$ and $\lambda=1$. For $p>1$ the problem was settled in [{lunq}], with thresholds $\lambda=2^{1/p-1}$ and $\lambda=1$. For $00$, thereby completing the classification.

\section{Slack variables and greedy strategies}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^p$. Define the slack variables
\[
A_n=\lambda n-S_n,\qquad B_n=n-Q_n .
\]
The rules are equivalent to requiring $A_n\ge0$ after Alice's moves and $B_n\ge0$ after Bazza's moves. The updates are
\begin{align*}
A_n &= A_{n-1}+\lambda-x_n,\\
B_n &= B_{n-1}+1-x_n^p .
\end{align*}

A \emph{greedy} strategy consists in taking the largest admissible move, i.e. making the corresponding slack exactly zero:
\[
\text{Alice (odd $n$)}:\; x_n=A_{n-1}+\lambda,\qquad
\text{Bazza (even $n$)}:\; x_n=(B_{n-1}+1)^{1/p}.
\]

The following monotonicity lemma (proved in [{lxlv}]) justifies the optimality of greedy play: any deviation from the greedy move can only increase the opponent’s slack, hence cannot improve the player’s own prospects. Consequently, if a player can force a win (or a draw) by using the greedy strategy, then no alternative strategy can prevent that outcome. Therefore we may restrict attention to greedy strategies when searching for winning strategies.

\section{Reduction to a one‑dimensional recurrence}

Assume both players follow their greedy strategies. Let $a_k=A_{2k}$ be Alice’s slack after Bazza’s $k$-th move and $b_k=B_{2k-1}$ be Bazza’s slack after Alice’s $k$-th move. A direct computation gives
\begin{align}
b_k &= 1-(a_{k-1}+\lambda)^p,\label{eq:b}\\
a_k &= \lambda-\bigl(b_k+1\bigr)^{1/p}
      = \lambda-\bigl(2-(a_{k-1}+\lambda)^p\bigr)^{1/p}.\label{eq:a}
\end{align}
Introduce $s_k=a_{k-1}+\lambda$; then (\ref{eq:a}) becomes the recurrence
\begin{equation}\label{eq:rec}
s_{k+1}=2\lambda-\bigl(2-s_k^{\,p}\bigr)^{1/p},\qquad k\ge1,\qquad s_1=\lambda .
\end{equation}
The game can continue as long as $s_k\ge0$ (so that Alice can move) and $s_k^{\,p}\le2$ (so that Bazza can move). If $s_k<0$ then Alice loses; if $s_k^{\,p}>2$ then Bazza loses.

\section{A key inequality}

For $s\ge0$ with $s^{\,p}\le2$ set $t=(2-s^{\,p})^{1/p}\ge0$. Then $s^{\,p}+t^{\,p}=2$. Define
\[
H(s)=s+t=s+\bigl(2-s^{\,p}\bigr)^{1/p}.
\]

\begin{lemma}\label{lem:Hrange}
For any $s\ge0$ with $s^{\,p}\le2$,
\begin{enumerate}
\item If $p\ge1$ then $2^{1/p}\le H(s)\le 2$, with equality $H(s)=2$ iff $s=1$.
\item If $p\le1$ then $2\le H(s)\le 2^{1/p}$, with equality $H(s)=2$ iff $s=1$.
\end{enumerate}
\end{lemma}
\begin{proof}
The equality $H(0)=H(2^{1/p})=2^{1/p}$ is immediate. It remains to bound $H(s)$ from the other side.

Consider the function $\phi(x)=x^p$ on $[0,\infty)$. For $p\ge1$ the function $\phi$ is convex; for $p\le1$ it is concave. Apply Jensen’s inequality to the numbers $s$ and $t$:
\[
\phi\!\Bigl(\frac{s+t}{2}\Bigr)\;\begin{cases}
\displaystyle\le\frac{\phi(s)+\phi(t)}{2} & (p\ge1)\\[4mm]
\displaystyle\ge\frac{\phi(s)+\phi(t)}{2} & (p\le1)
\end{cases}
\]
Because $s^{\,p}+t^{\,p}=2$, the right‑hand side equals $1$ in both cases. Hence
\[
\Bigl(\frac{s+t}{2}\Bigr)^{\!p}\;\begin{cases}\le1 & (p\ge1)\\[2mm]\ge1 & (p\le1)\end{cases}
\]
which is equivalent to
\[
\frac{s+t}{2}\;\begin{cases}\le1 & (p\ge1)\\[2mm]\ge1 & (p\le1)\end{cases}
\]
i.e. $s+t\le2$ for $p\ge1$ and $s+t\ge2$ for $p\le1$. Equality occurs exactly when $s=t$, which together with $s^{\,p}+t^{\,p}=2$ gives $s^{\,p}=1$, i.e. $s=1$.

Combining these bounds with the values at the endpoints yields the stated ranges.
\end{proof}

\section{Fixed points and the draw region}

A fixed point of (\ref{eq:rec}) satisfies $s=2\lambda-H(s)$, i.e. $H(s)=2\lambda$. By Lemma~\ref{lem:Hrange} the equation $H(s)=2\lambda$ has a solution $s\in[0,2^{1/p}]$ iff $2\lambda$ belongs to the range of $H$. Therefore
\begin{itemize}
\item For $p\ge1$ a fixed point exists iff $2^{1/p}\le2\lambda\le2$, i.e.
  \[
  2^{1/p-1}\le\lambda\le1 .
  \]
\item For $p\le1$ a fixed point exists iff $2\le2\lambda\le2^{1/p}$, i.e.
  \[
  1\le\lambda\le2^{1/p-1}.
  \]
\end{itemize}
In both cases the fixed point is unique and attracting; the sequence $\{s_k\}$ converges to it. Consequently, when $\lambda$ lies in the corresponding interval, both slacks stay bounded away from $- \infty$ and the game can continue forever. By the monotonicity lemma neither player can force a win; the game is a draw.

\section{Winning thresholds}

When $\lambda$ lies outside the draw interval, no fixed point exists and the sequence $\{s_k\}$ is monotonic.

\begin{itemize}
\item \textbf{Case $p\ge1$, $\lambda<2^{1/p-1}$.} Then $2\lambda<2^{1/p}\le H(s)$ for all $s$, hence $s_{k+1}-s_k=2\lambda-H(s_k)<0$. The sequence is strictly decreasing. Because $F(0)=2\lambda-2^{1/p}<0$, after finitely many steps $s_k$ becomes negative, at which point Alice cannot move. Hence \emph{Bazza wins}.

\item \textbf{Case $p\ge1$, $\lambda>1$.} Now $2\lambda>2\ge H(s)$, so $s_{k+1}-s_k>0$; the sequence increases. Since $H(s)\le2$, we have $s_{k+1}\ge s_k+2(\lambda-1)$. Thus $s_k$ grows linearly and eventually exceeds $2^{1/p}$, making $s_k^{\,p}>2$. At that moment Bazza cannot move, so \emph{Alice wins}.

\item \textbf{Case $p\le1$, $\lambda<1$.} Then $2\lambda<2\le H(s)$, whence $s_{k+1}2^{1/p-1}$.} Now $2\lambda>2^{1/p}\ge H(s)$, so $s_{k+1}>s_k$. The sequence increases linearly and eventually exceeds $2^{1/p}$, causing Bazza to lose. Thus \emph{Alice wins}.
\end{itemize}

\section{Main theorem}

Summarising the above analysis we obtain the complete classification.

\begin{theorem}\label{thm:main}
For the generalized inekoalaty game with parameter $\lambda>0$ and exponent $p>0$:
\begin{enumerate}
\item If $p\ge1$ then
\begin{itemize}
\item Bazza has a winning strategy for $\lambda<2^{1/p-1}$,
\item neither player has a winning strategy for $2^{1/p-1}\le\lambda\le1$ (the game is a draw),
\item Alice has a winning strategy for $\lambda>1$.
\end{itemize}
\item If $p\le1$ then
\begin{itemize}
\item Bazza has a winning strategy for $\lambda<1$,
\item neither player has a winning strategy for $1\le\lambda\le2^{1/p-1}$ (the game is a draw),
\item Alice has a winning strategy for $\lambda>2^{1/p-1}$.
\end{itemize}
\end{enumerate}
In all cases the greedy strategies are optimal.
\end{theorem}

For $p=2$ we recover the original result $\lambda_c=\sqrt2/2$, $\lambda_u=1$. The special case $p=1$ gives a single threshold $\lambda=1$.

\section{Discussion}

The proof relies on three ingredients: (i) the reduction to greedy play via a monotonicity lemma, (ii) the inequality $s+(2-s^{\,p})^{1/p}\le2$ (or $\ge2$) obtained from Jensen’s inequality, and (iii) a simple analysis of the resulting recurrence. The same approach works for all $p>0$, revealing a symmetric duality between the cases $p>1$ and $p<1$.

\section*{Acknowledgements}

We thank the authors of [{lunq}] for solving the case $p>1$ and of [{8nk6}] for conjecturing the thresholds for $p<1$.

\begin{thebibliography}{9}
\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\bibitem{lunq} {lunq}: Generalized Inekoalaty Game with $L^p$ Constraints.
\bibitem{8nk6} {8nk6}: Generalized Inekoalaty Game with Exponent $p$: Thresholds and Conjectures.
\bibitem{lxlv} {lxlv}: Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

reference=[mxiv]
title=Complete Solution of the Generalized Inekoalaty Game for All Exponents p>0
author=slsx
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[analyze_p_less_1_simple.py,complete_proof.tex]

Review submitted for publication [b1xz].

exit_code: 0
duration_ms: 410
stdout:
```
p=1, q=2
γ      λ_c (sim)   λ_c (paper)  λ_c·γ^(3/2)
0.25   1.090501      1.0905       0.136313
0.50   1.184840      1.1848       0.418904
0.75   1.196495      1.1965       0.777146
1.00   0.707107      0.7071       0.707107
1.25   0.512871      0.5129       0.716759
1.50   0.389888      0.3899       0.716270
2.00   0.248061      0.2481       0.701621

```
stderr:
```
```

reference=[b1xz]
title=Scaling Laws for Generalized Inekoalaty Games with Power-Law Growth
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We analyze the asymptotic behavior of the generalized inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. Using dominant balance arguments we derive scaling exponents for the optimal moves and predict the critical parameter $\lambda_c$ separating Bazza and Alice wins. For $\alpha=\beta>1$ we find $\lambda_c \sim C \alpha^{-\theta}$ with $\theta = 3/2$ for $p=1,q=2$, and $\theta = 0$ for $p=q$. For $\alpha=\beta<1$ the scaling changes sign. Numerical simulations confirm the predictions.

# Scaling Laws for Generalized Inekoalaty Games with Power‑Law Growth

## Introduction

The inekoalaty game [{rkrw}] is a two‑player alternating‑move game with linear and quadratic cumulative constraints. Its complete solution exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$ [{zn8k}]. Generalizations where the exponents in the constraints are allowed to vary have been studied [{lunq}, {8nk6}, {6y2s}]. In this work we focus on the **scaling behavior** of the critical parameter $\lambda_c$ when the right‑hand sides grow as powers $n^\alpha$, $n^\beta$ with $\alpha,\beta\neq1$.

The game is defined as follows. Let $p,q>0$ and $\alpha,\beta>0$. On odd turns $n$ Alice chooses $x_n\ge0$ with
$$ \sum_{i=1}^n x_i^{\,p}\le\lambda n^{\alpha}, $$
and on even turns Bazza chooses $x_n\ge0$ with
$$ \sum_{i=1}^n x_i^{\,q}\le n^{\beta}. $$
If a player cannot move, the opponent wins; if the game never ends, neither wins. The original game corresponds to $p=1$, $q=2$, $\alpha=\beta=1$.

Under greedy optimal play (which can be justified by monotonicity lemmas [{lxlv}]) the game reduces to the recurrence
\begin{align}
a_k^{\,p}&=\lambda\bigl((2k-1)^{\alpha}-(2k-3)^{\alpha}\bigr)-b_{k-1}^{\,p},\label{eq:a}\\
b_k^{\,q}&=\bigl((2k)^{\beta}-(2k-2)^{\beta}\bigr)-a_k^{\,q},\label{eq:b}
\end{align}
where $a_k=x_{2k-1}$, $b_k=x_{2k}$. The game continues as long as all quantities under the roots are non‑negative.

We are interested in the **critical value** $\lambda_c(\alpha,\beta,p,q)$ that separates the regime where Bazza has a winning strategy ($\lambda<\lambda_c$) from that where Alice has a winning strategy ($\lambda>\lambda_c$). For $\alpha=\beta=1$ an interval of $\lambda$ where the game is a draw often exists; when $\alpha\neq1$ or $\beta\neq1$ this draw interval typically vanishes [{6y2s}].

## Asymptotic analysis for large $k$

Assume $\alpha=\beta=\gamma$ and consider $k\gg1$. Write
$$ D_\gamma(k)=(2k-1)^{\gamma}-(2k-3)^{\gamma}=2\gamma (2k)^{\gamma-1}\bigl[1+O(k^{-1})\bigr], $$
and similarly $\Delta_\gamma(k)=(2k)^{\gamma}-(2k-2)^{\gamma}=2\gamma (2k)^{\gamma-1}\bigl[1+O(k^{-1})\bigr]$. Denote $C=2\gamma(2)^{\gamma-1}$; then $D_\gamma(k)\sim C k^{\gamma-1}$, $\Delta_\gamma(k)\sim C k^{\gamma-1}$.

We look for asymptotic scaling of the form
$$ a_k\sim A k^{\mu},\qquad b_k\sim B k^{\nu}. $$
Substituting into (\ref{eq:a})–(\ref{eq:b}) and keeping the dominant terms gives the system
\begin{align}
A^{\,p}k^{p\mu}&\sim \lambda C k^{\gamma-1}-B^{\,p}k^{p\nu},\label{eq:adom}\\
B^{\,q}k^{q\nu}&\sim C k^{\gamma-1}-A^{\,q}k^{q\mu}.\label{eq:bdom}
\end{align}

### Balanced scaling

If the two terms on the right‑hand side of each equation are of the same order, we must have
$$ p\mu = p\nu = \gamma-1,\qquad q\nu = q\mu = \gamma-1. $$
This forces $\mu=\nu=(\gamma-1)/p=(\gamma-1)/q$, which is possible only when $p=q$. For $p=q$ we obtain $\mu=\nu=(\gamma-1)/p$, and the leading terms balance provided
$$ A^{\,p}= \lambda C-B^{\,p},\qquad B^{\,p}=C-A^{\,p}. $$
Adding yields $A^{\,p}+B^{\,p}=C(\lambda+1)- (A^{\,p}+B^{\,p})$, hence $A^{\,p}+B^{\,p}=C(\lambda+1)/2$. Subtracting gives $A^{\,p}-B^{\,p}=C(\lambda-1)$. Solving gives
$$ A^{\,p}=C\frac{\lambda+1}{2}+C\frac{\lambda-1}{2}=C\lambda,\qquad
   B^{\,p}=C\frac{\lambda+1}{2}-C\frac{\lambda-1}{2}=C. $$
Thus $A=(C\lambda)^{1/p}$, $B=C^{1/p}$. The solution is feasible as long as $A^{\,q}= (C\lambda)^{q/p}\le C$ (so that $b_k^{\,q}\ge0$). For $p=q$ this condition reduces to $\lambda\le1$. Moreover $B^{\,p}=C\le \lambda C$ requires $\lambda\ge1$. Hence the only possible balanced scaling occurs at $\lambda=1$. At that value $A=B=C^{1/p}$, and the game can continue indefinitely. This explains why for $p=q$ the critical $\lambda_c$ is extremely close to $1$ independently of $\gamma$, as observed numerically (Table~1).

### Dominant‑subdominant scaling

When $p\neq q$ the two terms on the right of (\ref{eq:adom})–(\ref{eq:bdom}) cannot be of the same order. Which term dominates depends on the sign of $\gamma-1$ and on the ratios $p/q$, $q/p$.

**Case $\gamma>1$ (super‑linear growth).** The driving terms $C k^{\gamma-1}$ grow with $k$. Suppose $p1$, the exponent $q(\gamma-1)/p > \gamma-1$, and the second term dominates for large $k$. Hence the right‑hand side becomes negative, implying $B^{\,q}<0$, which is impossible. Therefore the assumed scaling cannot hold; the sequence must leave the admissible region for any $\lambda\neq\lambda_c$. A critical $\lambda_c$ exists where the two terms cancel to leading order, i.e. where
$$ C k^{\gamma-1}-(\lambda C)^{q/p}k^{q(\gamma-1)/p}=0 $$
for the dominant exponent. Balancing the exponents forces $q(\gamma-1)/p=\gamma-1$, i.e. $p=q$, which is excluded. Thus the cancellation must occur at the next order. A refined analysis (matched asymptotics) shows that the leading‑order term of $a_k$ is still $A k^{(\gamma-1)/p}$, but the coefficient $A$ is not exactly $(\lambda C)^{1/p}$; it is determined by a solvability condition that involves the next‑order corrections. This condition yields the scaling of $\lambda_c$.

**Heuristic scaling argument.** Dimensional analysis suggests that $\lambda_c$ should be proportional to $C^{-1}$ times a dimensionless function of $p,q$. Since $C\propto\gamma(2)^{\gamma-1}\propto\gamma$ for fixed $\gamma$, we expect $\lambda_c\propto\gamma^{-1}$ times a power of the ratio $p/q$. Numerical data for $p=1$, $q=2$ indicate $\lambda_c\propto\gamma^{-3/2}$ for $\gamma>1$ (Table~2). For $p=1$, $q=3$ the exponent appears to be similar.

**Case $\gamma<1$ (sub‑linear growth).** Now the driving terms decay with $k$. The roles of the players are effectively reversed, and the scaling of $\lambda_c$ changes sign. Numerical results show that $\lambda_c>1$ for $\gamma<1$ and increases as $\gamma$ decreases.

## Numerical results

We computed $\lambda_c$ by binary search on the recurrence with up to $10^4$ turns. The results for $\alpha=\beta=\gamma$ are summarised below.

*Table 1: $\lambda_c$ for $p=q=2$.*
| $\gamma$ | $\lambda_c$ |
|----------|-------------|
| 0.5      | 0.9992      |
| 1.0      | 0.9983      |
| 1.5      | 0.9975      |
| 2.0      | 0.9967      |

As predicted, $\lambda_c$ is extremely close to $1$ and depends only weakly on $\gamma$.

*Table 2: $\lambda_c$ for $p=1$, $q=2$.*
| $\gamma$ | $\lambda_c$ | $\lambda_c\,\gamma^{3/2}$ |
|----------|-------------|---------------------------|
| 0.25     | 1.0905      | 0.1363                    |
| 0.5      | 1.1848      | 0.4189                    |
| 0.75     | 1.1965      | 0.7771                    |
| 1.0      | 0.7071      | 0.7071                    |
| 1.25     | 0.5129      | 0.7168                    |
| 1.5      | 0.3899      | 0.7162                    |
| 2.0      | 0.2481      | 0.7016                    |

For $\gamma\ge1$ the product $\lambda_c\gamma^{3/2}$ is approximately constant ($\approx0.71$), confirming the scaling $\lambda_c\propto\gamma^{-3/2}$. For $\gamma<1$ the scaling is different; here $\lambda_c$ exceeds $1$ and grows as $\gamma$ decreases.

*Table 3: $\lambda_c$ for $p=1$, $q=3$.*
| $\gamma$ | $\lambda_c$ | $\lambda_c\,\gamma^{3/2}$ |
|----------|-------------|---------------------------|
| 0.5      | 1.1225      | 0.3970                    |
| 0.75     | 1.1672      | 0.7576                    |
| 1.0      | 0.6300      | 0.6300                    |
| 1.25     | 0.4470      | 0.6247                    |
| 1.5      | 0.3355      | 0.6164                    |

Again the scaling $\lambda_c\propto\gamma^{-3/2}$ holds for $\gamma\ge1$.

## Discussion

The asymptotic analysis reveals why the draw interval present for $\alpha=\beta=1$ disappears when $\alpha,\beta\neq1$: the non‑autonomous driving terms break the delicate balance that allowed a continuum of fixed points. Instead a single critical $\lambda_c$ emerges, whose scaling with the growth exponent $\gamma$ follows a power law.

The exponent $-3/2$ observed for $p=1$, $q=2$ and $p=1$, $q=3$ suggests a universal scaling $\lambda_c\propto\gamma^{-3/2}$ for $\gamma>1$ and $p

System prompt updated

reference=[f1cn]
title=Generalized Inekoalaty Game with Different Exponents
author=8wf0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]

Publication submitted.

(0 found)

Review submitted for publication [knjh].

reference=[knjh]
title=Generalized Inekoalaty Game with Linear and Quadratic Constraints
author=muk7
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[InekoalatyGeneralized.lean,generalized.tex]
abstract = We generalize the inekoalaty game to two parameters α,β>0 governing the linear and quadratic constraints. We prove that Bazza wins if α < √(2β)/2, Alice wins if α > √β, and the game is a draw for √(2β)/2 ≤ α ≤ √β. The original game corresponds to β=1. The proof extends the slack‑variable and greedy‑strategy approach of earlier solutions [{rkrw}, {zn8k}].

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{enumitem}
\usepackage{graphicx}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{definition}{Definition}

\title{Generalized Inekoalaty Game with Linear and Quadratic Constraints}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We generalize the inekoalaty game by introducing two parameters $\alpha,\beta>0$: on odd turns Alice must keep the sum $\sum x_i\le\alpha n$, while on even turns Bazza must keep the sum of squares $\sum x_i^2\le\beta n$. We completely classify the outcomes: Bazza has a winning strategy if $\alpha<\frac{\sqrt{2\beta}}{2}$, Alice has a winning strategy if $\alpha>\sqrt{\beta}$, and the game can be drawn forever if $\frac{\sqrt{2\beta}}{2}\le\alpha\le\sqrt{\beta}$. The original inekoalaty game corresponds to $\beta=1$, $\alpha=\lambda$. The proof extends the slack‑variable and greedy‑strategy approach of the earlier solutions [{rkrw}, {zn8k}].
\end{abstract}

\section{Introduction}

The two‑player inekoalaty game, introduced in the present research system, is defined by a single parameter $\lambda>0$. In this note we consider a natural generalization with two independent parameters $\alpha,\beta>0$ governing the linear and quadratic constraints, respectively.

\paragraph{Rules.} On turn $n=1,2,\dots$
\begin{itemize}
\item If $n$ is odd, Alice chooses $x_n\ge0$ such that $x_1+\cdots+x_n\le\alpha n$.
\item If $n$ is even, Bazza chooses $x_n\ge0$ such that $x_1^2+\cdots+x_n^2\le\beta n$.
\end{itemize}
If a player cannot choose a suitable $x_n$, the game ends and the other player wins. If the game never ends, neither player wins. All previous choices are known to both players.

The original game is the special case $\beta=1$, $\alpha=\lambda$. The aim is to determine, for each pair $(\alpha,\beta)$, which player (if any) has a strategy that guarantees a win.

\section{Slack variables and greedy strategies}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$. Define the slack variables
\[
A_n=\alpha n-S_n,\qquad B_n=\beta n-Q_n .
\]
Initially $A_0=0$, $B_0=0$. After choosing $x_n\ge0$ we have
\begin{align}
A_n &= A_{n-1}+\alpha-x_n,\label{eq:Agen}\\
B_n &= B_{n-1}+\beta-x_n^2.\label{eq:Bgen}
\end{align}
Alice, on odd $n$, must keep $A_n\ge0$; Bazza, on even $n$, must keep $B_n\ge0$.

As in the original game, a \emph{greedy} strategy is optimal: each player chooses the largest admissible $x_n$, i.e.\ makes the corresponding slack exactly zero. Thus
\[
\text{Alice (odd $n$): } x_n = A_{n-1}+\alpha,\qquad
\text{Bazza (even $n$): } x_n = \sqrt{\,B_{n-1}+\beta\,}.
\]

The following monotonicity lemma (analogous to Lemma~1 of [{zn8k}]) shows that deviating from the greedy choice cannot improve a player's own prospects; therefore we may restrict attention to greedy play when searching for winning strategies.

\begin{lemma}[Monotonicity]\label{lem:monotone-gen}
Let $(A_{n-1},B_{n-1})$ be the state before a player's turn.
\begin{enumerate}
\item If Alice chooses $x_n\le A_{n-1}+\alpha$ (so that $A_n\ge0$), then $A_n\ge0$ and $B_n\ge B_n^{\mathrm{gr}}$, where $B_n^{\mathrm{gr}}$ is the value obtained by the greedy choice.
\item If Bazza chooses $x_n\le\sqrt{B_{n-1}+\beta}$ (so that $B_n\ge0$), then $B_n\ge0$ and $A_n\ge A_n^{\mathrm{gr}}$, where $A_n^{\mathrm{gr}}$ is the value obtained by the greedy choice.
\end{enumerate}
\end{lemma}
\begin{proof}
Same as in [{zn8k}]; the only change is replacing $\lambda$ by $\alpha$ and $1$ by $\beta$.
\end{proof}

\section{Reduction to a one‑dimensional recurrence}

Assume both players adopt the greedy strategies. After Alice's $(2k-1)$-st move we have $A_{2k-1}=0$ and
\[
B_{2k-1}= \beta(2k-1)-Q_{2k-1}= \beta - (a_{k-1}+\alpha)^2,
\]
where we set $a_k=A_{2k}$ (Alice's slack after Bazza's $2k$-th move) with $a_0=0$. After Bazza's $2k$-th move we have $B_{2k}=0$ and
\[
A_{2k}= \alpha(2k)-S_{2k}= \alpha-\sqrt{2\beta-(a_{k-1}+\alpha)^2}.
\]
Thus we obtain the recurrence
\begin{equation}\label{eq:recurrence-gen}
a_k = \alpha-\sqrt{2\beta-(a_{k-1}+\alpha)^2},\qquad k\ge1,
\end{equation}
with the understanding that the square‑root requires $2\beta-(a_{k-1}+\alpha)^2\ge0$; if this becomes negative, Bazza cannot move and loses.

Define $s_k=a_{k-1}+\alpha$ (so $s_1=\alpha$). Then (\ref{eq:recurrence-gen}) becomes
\begin{equation}\label{eq:s-recurrence-gen}
s_{k+1}=2\alpha-\sqrt{2\beta-s_k^{\,2}},\qquad k\ge1,
\end{equation}
and the game continues as long as $s_k\ge0$ (Alice can move) and $s_k^2\le2\beta$ (Bazza can move).

\subsection{The function $f_{\beta}(s)=s+\sqrt{2\beta-s^2}$}

For $0\le s\le\sqrt{2\beta}$ define
\[
f_{\beta}(s)=s+\sqrt{2\beta-s^2}.
\]
The function increases on $[0,\sqrt{\beta}]$, attains its maximum $f_{\beta}(\sqrt{\beta})=2\sqrt{\beta}$, and decreases on $[\sqrt{\beta},\sqrt{2\beta}]$, with $f_{\beta}(0)=f_{\beta}(\sqrt{2\beta})=\sqrt{2\beta}$.

A fixed point of (\ref{eq:s-recurrence-gen}) satisfies $s=2\alpha-\sqrt{2\beta-s^2}$, i.e.\ $f_{\beta}(s)=2\alpha$. Hence a fixed point exists iff
\[
\sqrt{2\beta}\;\le\;2\alpha\;\le\;2\sqrt{\beta}\qquad\Longleftrightarrow\qquad
\frac{\sqrt{2\beta}}{2}\le\alpha\le\sqrt{\beta}.
\]

When a fixed point exists, the derivative of the map $g(s)=2\alpha-\sqrt{2\beta-s^2}$ at the fixed point is $g'(s)=s/\sqrt{2\beta-s^2}$. For the smaller fixed point (lying in $[0,\sqrt{\beta}]$) we have $g'(s)<1$, so it is attracting; for the larger fixed point (in $[\sqrt{\beta},\sqrt{2\beta}]$) we have $g'(s)>1$, so it is repelling. Consequently, when $\frac{\sqrt{2\beta}}{2}\le\alpha\le\sqrt{\beta}$ the sequence $\{s_k\}$ converges to the attracting fixed point, and both slacks stay bounded away from $-\infty$; the game can continue forever.

\section{Classification of outcomes}

\begin{theorem}\label{thm:main-gen}
For the generalized inekoalaty game with parameters $\alpha,\beta>0$:
\begin{enumerate}[label=(\roman*)]
\item If $\alpha<\dfrac{\sqrt{2\beta}}{2}$, Bazza has a winning strategy (the greedy strategy).
\item If $\dfrac{\sqrt{2β}}{2}\le\alpha\le\sqrt{\beta}$, neither player has a winning strategy; both players can force at least a draw by using the greedy strategy.
\item If $\alpha>\sqrt{\beta}$, Alice has a winning strategy (the greedy strategy).
\end{enumerate}
\end{theorem}

\begin{proof}
The three regimes correspond to the existence and position of fixed points of $f_{\beta}$.

\noindent\textbf{Case $\alpha<\frac{\sqrt{2\beta}}{2}$.} Then $2\alpha<\sqrt{2\beta}=f_{\beta}(0)=f_{\beta}(\sqrt{2\beta})$. Because $f_{\beta}$ is convex? Actually one can show that $g(s)=2\alpha-\sqrt{2\beta-s^2}$ satisfies $g(s)0$). Hence the game never terminates. By Lemma~\ref{lem:monotone-gen}, any deviation from greediness can only improve the opponent's position, so neither player can force a win.

\noindent\textbf{Case $\alpha>\sqrt{\beta}$.} Now $2\alpha>2\sqrt{\beta}=f_{\beta}(\sqrt{\beta})$, the maximum of $f_{\beta}$. Consequently $g(s)-s=2\alpha-f_{\beta}(s)>0$ for all $s<\sqrt{2\beta}$. Hence $\{s_k\}$ is strictly increasing as long as $s_k<\sqrt{2\beta}$. If it stayed bounded by $\sqrt{2\beta}$, it would converge to a fixed point, but no fixed point exists for $\alpha>\sqrt{\beta}$. Therefore $s_k$ must exceed $\sqrt{2\beta}$ after finitely many steps. When $s_k>\sqrt{2\beta}$, the expression under the square‑root in (\ref{eq:recurrence-gen}) becomes negative, i.e.\ $B_{2k-1}+\beta<0$; at the next even turn Bazza cannot choose any $x_{2k}$ with $B_{2k}\ge0$, so he loses. Thus Alice's greedy strategy wins.

For $\alpha>\sqrt{2\beta}$ the win is immediate: Alice can choose $x_1=\alpha$, giving $Q_1=\alpha^2>2\beta$, so Bazza already loses at $n=2$.
\end{proof}

\section{Remarks}

\begin{enumerate}
\item The thresholds are sharp: exactly at $\alpha=\frac{\sqrt{2\beta}}{2}$ and $\alpha=\sqrt{\beta}$ the game is still a draw (the greedy strategies keep both slacks nonnegative and the sequence converges to the boundary fixed point).
\item The original inekoalaty game is recovered by setting $\beta=1$; then $\frac{\sqrt2}{2}\le\lambda\le1$, in agreement with the earlier results.
\item The classification can be visualized in the $(\alpha,\beta)$‑plane (Figure~\ref{fig:phase}). The winning region for Bazza is the leftmost wedge $\alpha<\frac{\sqrt{2\beta}}{2}$, the drawing region is the curved strip between the parabola $\alpha=\frac{\sqrt{2\beta}}{2}$ and the line $\alpha=\sqrt{\beta}$, and the winning region for Alice is the rightmost wedge $\alpha>\sqrt{\beta}$.
\item The same analysis works if the constraints are required to hold after every turn, because the greedy strategies keep both slacks nonnegative at all times except possibly the slack of the player who has just moved, which is exactly zero.
\end{enumerate}

\section{Conclusion}

We have completely solved the generalized inekoalaty game with two parameters $\alpha,\beta$. The outcome depends only on the ratio $\alpha/\sqrt{\beta}$: Bazza wins when $\alpha/\sqrt{\beta}<\frac{\sqrt2}{2}$, the game is a draw when $\frac{\sqrt2}{2}\le\alpha/\sqrt{\beta}\le1$, and Alice wins when $\alpha/\sqrt{\beta}>1$. This extends the earlier solution of the one‑parameter game and reveals the underlying scaling symmetry.

\end{document}

(reviews are hidden until publication/rejection)

reference=[knjh]
title=Generalized Inekoalaty Game with Linear and Quadratic Constraints
author=muk7
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[InekoalatyGeneralized.lean,generalized.tex]

exit_code: 0
duration_ms: 321
stdout:
```
170

```
stderr:
```
```

(0 found)

Review submitted for publication [6y2s].

reference=[6y2s]
title=Generalized Inekoalaty Games with Power-Law Constraints
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We study a generalization of the inekoalaty game where Alice's constraint is $\sum x_i^p \le \lambda n^\alpha$ and Bazza's constraint is $\sum x_i^q \le n^\beta$. We derive recurrences under greedy strategies and analyze the phase diagram. For $\alpha=\beta=1$ (autonomous case) we find draw regions for many $(p,q)$ pairs. For $\alpha\neq\beta$ the draw region disappears, and there is a single critical $\lambda_c(\alpha,\beta,p,q)$ separating Bazza and Alice wins. We present numerical results and conjectures about scaling behavior.

# Generalized Inekoalaty Games with Power‑Law Constraints

## Introduction

The inekoalaty game [{rkrw}] is a two‑player game parameterized by $\lambda>0$.  On odd turns Alice chooses $x_n\ge0$ with $\sum_{i=1}^n x_i\le\lambda n$; on even turns Bazza chooses $x_n\ge0$ with $\sum_{i=1}^n x_i^2\le n$.  If a player cannot move, the opponent wins; if the game never ends, neither wins.  The problem is completely solved in [{rkrw}]: Alice wins for $\lambda>1$, Bazza wins for $\lambda<1/\sqrt2$, and the game is a draw for $1/\sqrt2\le\lambda\le1$.

In this work we consider a natural generalization.  Let $p,q>0$ and $\alpha,\beta>0$.  The rules become:

- On odd $n$ (Alice) she must satisfy
  $$\sum_{i=1}^n x_i^{\,p}\le\lambda n^{\alpha}.$$
- On even $n$ (Bazza) he must satisfy
  $$\sum_{i=1}^n x_i^{\,q}\le n^{\beta}.$$

The original game corresponds to $p=1$, $q=2$, $\alpha=\beta=1$.  We investigate for which parameters $(p,q,\alpha,\beta,\lambda)$ each player has a winning strategy.

## Greedy strategies and reduction to a recurrence

As in the original analysis [{rkrw}], we argue that optimal play for both players consists in using the whole available budget at each turn.  Indeed, Alice wants to make the sum of $q$‑th powers as large as possible (to threaten Bazza’s future constraint), while Bazza wants to make the sum of $p$‑th powers as large as possible (to threaten Alice’s future constraint).  Hence on her turn Alice chooses $x_n$ such that $\sum_{i=1}^n x_i^{\,p}= \lambda n^{\alpha}$, and on his turn Bazza chooses $x_n$ such that $\sum_{i=1}^n x_i^{\,q}= n^{\beta}$.

Write $a_k=x_{2k-1}$ (Alice’s $k$-th move) and $b_k=x_{2k}$ (Bazza’s $k$-th move).  From the equalities we obtain the recurrences
\begin{align}
a_k^{\,p}&=\lambda\bigl((2k-1)^{\alpha}-(2k-3)^{\alpha}\bigr)-b_{k-1}^{\,p},\label{eq:a}\\
b_k^{\,q}&=\bigl((2k)^{\beta}-(2k-2)^{\beta}\bigr)-a_k^{\,q}.\label{eq:b}
\end{align}
Thus the game reduces to studying the two‑dimensional recurrence \eqref{eq:a}--\eqref{eq:b} with initial conditions
$$a_1^{\,p}=\lambda,\qquad b_1^{\,q}=2^{\beta}-a_1^{\,q}.$$

The game continues as long as all quantities under the roots are non‑negative.  If $a_k^{\,p}$ becomes negative, Alice loses at turn $2k-1$; if $b_k^{\,q}$ becomes negative, Bazza loses at turn $2k$.

## The autonomous case $\alpha=\beta=1$

When $\alpha=\beta=1$ the increments are constant:
$$(2k-1)^{\alpha}-(2k-3)^{\alpha}=2,\qquad (2k)^{\beta}-(2k-2)^{\beta}=2.$$
Consequently the recurrence becomes autonomous:
\begin{align}
a_k^{\,p}&=2\lambda- b_{k-1}^{\,p},\label{eq:a1}\\
b_k^{\,q}&=2- a_k^{\,q}.\label{eq:b1}
\end{align}
Eliminating $b_{k-1}$ yields a one‑dimensional map for $a_k$:
$$a_k^{\,p}=2\lambda-\bigl(2- a_{k-1}^{\,q}\bigr)^{\,p/q}.$$
Define $f(x)=\bigl(2\lambda-(2-x^{\,q})^{p/q}\bigr)^{1/p}$; then $a_k=f(a_{k-1})$.  The game continues forever iff the sequence $(a_k)$ stays in the interval where both $a_k\ge0$ and $b_k\ge0$, i.e. $0\le a_k^{\,q}\le2$.

### Fixed points and stability

Fixed points satisfy $x^{\,p}=2\lambda-(2-x^{\,q})^{p/q}$.  Writing $y=x^{\,q}$ we obtain
$$y^{\,p/q}=2\lambda-(2-y)^{p/q}.$$
For $p=q$ this simplifies to $y=2\lambda-(2-y)$, i.e. $y=\lambda+1$.  Hence a fixed point exists only when $\lambda+1\le2$, i.e. $\lambda\le1$, and then $x=(\lambda+1)^{1/q}$.  The derivative of $f$ at this fixed point is $f'(x)=x^{\,q-p}$.  For $pq$ it is repelling.

For $p\neq q$ the equation can have zero, one or two solutions depending on $\lambda$.  A detailed analysis shows that for many $(p,q)$ there is an interval of $\lambda$ for which an attracting fixed point lies inside $(0,2^{1/q})$, giving rise to a **draw region** where neither player can force a win.  Table 1 lists examples obtained numerically.

| $p$ | $q$ | draw region $\lambda\in$ |
|-----|-----|--------------------------|
| 1   | 2   | [0.707, 1.000]           |
| 1   | 3   | [0.680, 1.000]           |
| 2   | 2   | [1.000, 1.020]           |
| 0.5 | 2   | [0.600, 1.020]           |
| 1.5 | 2   | [0.860, 1.020]           |

*Table 1: Draw regions for $\alpha=\beta=1$ (numerical estimates).*

When no attracting fixed point exists, the sequence $(a_k)$ eventually leaves the admissible interval; then one player loses and the other wins.  In such cases there is a single critical $\lambda_c$ separating Bazza’s wins (for $\lambda<\lambda_c$) from Alice’s wins (for $\lambda>\lambda_c$).

## The non‑autonomous case $\alpha\neq1$ or $\beta\neq1$

When $\alpha$ or $\beta$ differ from $1$, the increments $D_\alpha(k)=(2k-1)^{\alpha}-(2k-3)^{\alpha}$ and $D_\beta(k)=(2k)^{\beta}-(2k-2)^{\beta}$ depend on $k$.  For large $k$ we have the asymptotic expansions
$$D_\alpha(k)\sim 2\alpha (2k)^{\alpha-1},\qquad D_\beta(k)\sim 2\beta (2k)^{\beta-1}.$$

Thus the recurrence is non‑autonomous and its long‑time behaviour is governed by scaling laws.  Assume that $a_k\sim A k^{\gamma}$, $b_k\sim B k^{\delta}$.  Substituting into \eqref{eq:a}--\eqref{eq:b} and balancing the leading powers yields a system of equations for the exponents $\gamma,\delta$.  The admissible solution depends on the sign of $\alpha-1-p\gamma$ and $\beta-1-q\delta$.

Numerical simulations indicate that **the draw region disappears** as soon as $\alpha\neq\beta$ or $\alpha=\beta\neq1$.  Instead there is a single critical value $\lambda_c(\alpha,\beta,p,q)$ such that

- for $\lambda<\lambda_c$ Bazza wins,
- for $\lambda>\lambda_c$ Alice wins.

Table 2 gives examples for $p=1$, $q=2$.

| $\alpha$ | $\beta$ | $\lambda_c$ |
|----------|----------|-------------|
| 0.5      | 0.5      | 1.185       |
| 0.8      | 0.8      | 1.200       |
| 1.2      | 1.2      | 0.546       |
| 1.5      | 0.5      | 0.276       |
| 0.5      | 1.5      | 1.688       |

*Table 2: Critical $\lambda_c$ for $p=1$, $q=2$ when $\alpha\neq1$ or $\beta\neq1$.*

### Scaling conjectures

For $\alpha=\beta\neq1$ the critical $\lambda_c$ seems to satisfy
$$\lambda_c \propto (\alpha)^{-\theta}$$
with $\theta\approx0.5$ for $p=1$, $q=2$.  More generally, we conjecture that the critical point is determined by the condition that the two leading terms in the recurrence balance asymptotically, leading to
$$\lambda_c \sim C\, \alpha^{a}\beta^{b} \,(p,q\text{‑dependent factor}).$$

A detailed asymptotic analysis will be presented in a future work.

## Conclusion

We have introduced a multi‑parameter generalization of the inekoalaty game and reduced it to a recurrence under greedy optimal play.  When the right‑hand side exponents are equal to $1$ (autonomous case) the game can exhibit a draw interval for a wide range of $(p,q)$.  When the exponents differ from $1$ the draw interval vanishes and a single threshold $\lambda_c$ separates the two players’ winning regions.

Several directions remain open:

1. **Rigorous proof of optimality** of the greedy strategies.
2. **Complete classification** of the autonomous case: for which $(p,q)$ does a draw interval exist, and what are its endpoints?
3. **Asymptotic derivation** of $\lambda_c$ for general $\alpha,\beta,p,q$.
4. **Extension to other norms**, e.g. $L^r$ constraints with different $r$ on odd and even turns.

The generalized inekoalaty game offers a rich playground for studying the interplay of different growth constraints in a simple deterministic two‑player setting.

(reviews are hidden until publication/rejection)

reference=[6y2s]
title=Generalized Inekoalaty Games with Power-Law Constraints
author=3jl0
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[]

Review submitted for publication [vqh5].

reference=[vqh5]
title=The Inekoalaty Game and Its Generalizations: A Survey
author=slsx
reviews:ACCEPT, ACCEPT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[survey.tex]
abstract = We survey recent results on the two-player inekoalaty game and its variants. The original game, solved in [{zn8k}] and [{rkrw}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Several extensions have been studied: swapping the constraints, replacing the square‑sum by an $L^p$ constraint, and computer‑verified formalizations of the key lemmas. We summarize the main theorems, list open problems, and suggest directions for future research.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{url}
\usepackage{hyperref}

\title{The Inekoalaty Game and Its Generalizations: A Survey}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We survey recent results on the two-player inekoalaty game and its variants. The original game, solved in [{zn8k}] and [{rkrw}], exhibits sharp thresholds at $\lambda=\sqrt2/2$ and $\lambda=1$. Several extensions have been studied: swapping the constraints, replacing the square‑sum by an $L^p$ constraint, and computer‑verified formalizations of the key lemmas. We summarize the main theorems, list open problems, and suggest directions for future research.
\end{abstract}

\section{The original game}

The inekoalaty game is a perfect‑information two‑player game depending on a parameter $\lambda>0$. Players Alice and Bazza alternate turns, with Alice moving on odd turns and Bazza on even turns. On turn $n$ the moving player chooses a number $x_n\ge0$ subject to a cumulative constraint:
\begin{itemize}
\item for odd $n$: $x_1+\dots+x_n\le\lambda n$,
\item for even $n$: $x_1^2+\dots+x_n^2\le n$.
\end{itemize}
If a player cannot choose a suitable $x_n$, the game ends and the other player wins; if the game continues forever, neither wins.

The complete solution, obtained independently in [{rkrw}] and [{zn8k}], is:
\begin{itemize}
\item \textbf{Bazza wins} for $\lambda<\dfrac{\sqrt2}{2}$.
\item \textbf{Draw} for $\dfrac{\sqrt2}{2}\le\lambda\le1$.
\item \textbf{Alice wins} for $\lambda>1$.
\end{itemize}
Both proofs use slack variables $A_n=\lambda n-S_n$, $B_n=n-Q_n$ and show that greedy strategies (each player always takes the largest admissible number) are optimal. The greedy play reduces to the recurrence
\begin{equation}\label{eq:rec2}
s_{k+1}=2\lambda-\sqrt{2-s_k^{2}},\qquad s_1=\lambda,
\end{equation}
whose fixed‑point behaviour gives the thresholds.

\section{Computer‑verified components}

Several authors have formalised parts of the solution in the Lean theorem prover.

\begin{itemize}
\item [{araj}] verifies the key inequalities $s+\sqrt{2-s^2}\le2$ and $s+\sqrt{2-s^2}\ge\sqrt2$, and proves that for $\lambda>1$ the sequence (\ref{eq:rec2}) eventually exceeds $\sqrt2$, while for $\lambda<\sqrt2/2$ it becomes negative.
\item [{lxlv}] formalises the monotonicity lemmas that justify the optimality of greedy strategies: any deviation from the greedy move can only increase the opponent’s slack.
\end{itemize}
These formalisations provide a rigorous, machine‑checked foundation for the analytic arguments.

\section{Generalization to $L^p$ constraints}

A natural extension replaces the square‑sum constraint by an $L^p$ norm. In the generalized game Bazza must satisfy $\sum x_i^p\le n$ on even turns, while Alice’s constraint remains linear.

For $p>1$ the problem is solved in [{lunq}]. Using Hölder’s inequality one obtains the recurrence
\[
s_{k+1}=2\lambda-(2-s_k^{\,p})^{1/p},
\]
and the thresholds become
\begin{itemize}
\item Bazza wins for $\lambda<2^{1/p-1}$,
\item Draw for $2^{1/p-1}\le\lambda\le1$,
\item Alice wins for $\lambda>1$.
\end{itemize}
For $p=2$ this recovers the original thresholds.

For $p<1$ the situation appears to be different. Numerical experiments [{8nk6}] suggest that the lower threshold is $\lambda=1$ and the upper threshold is $\lambda_u(p)=2^{1/p-1}$, with a draw region between them. A rigorous proof is still open.

\section{Symmetry and swapped constraints}

If the roles of the constraints are swapped (Alice faces the quadratic constraint, Bazza the linear one) the recurrence is unchanged but the interpretation of the variable $s_k$ is different. Consequently, as shown in [{1sm0}], the winning thresholds become
\begin{itemize}
\item Alice wins for $\lambda<\dfrac{\sqrt2}{2}$,
\item Draw for $\dfrac{\sqrt2}{2}\le\lambda\le1$,
\item Bazza wins for $\lambda>1$.
\end{itemize}
Thus the thresholds are the same numbers as in the original game, but the winning players are exchanged.

\section{Open problems}

\begin{enumerate}
\item \textbf{Proof for $p<1$.} Establish rigorously the thresholds conjectured in [{8nk6}] for the generalized game with $00$). What are the winning regions as functions of $p,q$?
\item \textbf{Asymmetric turn order.} What happens if Alice moves on even turns and Bazza on odd turns? The recurrence changes, possibly leading to different thresholds.
\item \textbf{Continuous‑time analogue.} Replace the discrete turns by a continuous time variable; the constraints become integral inequalities. Does the game still exhibit sharp thresholds?
\item \textbf{Multi‑player versions.} Consider three or more players with different constraints. Is there a systematic way to determine the outcome?
\item \textbf{Randomized strategies.} Allow players to choose distributions over moves; does randomness change the thresholds?
\end{enumerate}

\section{Conclusion}

The inekoalaty game provides a neat example of a two‑player constraint game with a complete analytic solution. Its generalizations lead to a rich family of recurrences whose fixed‑point analysis yields sharp thresholds. Computer‑verified proofs have already been produced for several key lemmas, enhancing the reliability of the results. Many natural variants remain to be explored, offering opportunities for further research in combinatorial game theory and analysis.

\section*{Acknowledgements}

We thank the authors of the cited publications for their contributions.

\bibliographystyle{plain}
\begin{thebibliography}{9}

\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\bibitem{rkrw} {rkrw}: Optimal Strategies for the Inekoalaty Game.
\bibitem{lunq} {lunq}: Generalized Inekoalaty Game with $L^p$ Constraints.
\bibitem{1sm0} {1sm0}: Correct thresholds for the swapped inekoalaty game.
\bibitem{araj} {araj}: Computer‑verified recurrence analysis for the inekoalaty game.
\bibitem{lxlv} {lxlv}: Optimality of greedy strategies in the inekoalaty game: a Lean formalization.
\bibitem{8nk6} {8nk6}: Generalized Inekoalaty Game with Exponent $p$: Thresholds and Conjectures.

\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

Review submitted for publication [1sm0].

reference=[1sm0]
title=Correct thresholds for the swapped inekoalaty game
author=fi8r
reviews:ACCEPT, PENDING, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We correct the conjecture for the swapped inekoalaty game (Alice quadratic, Bazza linear). Through simulation and analysis of the recurrence, we show that Alice wins for $\lambda < \sqrt{2}/2$, Bazza wins for $\lambda > 1$, and the game is a draw for $\sqrt{2}/2 \le \lambda \le 1$. These thresholds are the same as in the original game, but with the players' roles interchanged.

# Correct thresholds for the swapped inekoalaty game

## Introduction

In a previous note we conjectured thresholds for the swapped inekoalaty game (Alice constrained by the sum of squares, Bazza by the linear sum). Numerical experiments now show that the correct thresholds are exactly the same numbers as in the original game, but with the winning players exchanged.

Specifically, let $\lambda>0$ be the parameter. Then

- **Alice has a winning strategy** iff $\lambda<\dfrac{\sqrt2}{2}$;
- **Bazza has a winning strategy** iff $\lambda>1$;
- for $\dfrac{\sqrt2}{2}\le\lambda\le1$ **neither player has a winning strategy**; the game can be forced to continue forever (a draw).

Thus the thresholds are $\lambda=\frac{\sqrt2}{2}$ and $\lambda=1$, as in the original game, but the intervals in which each player wins are swapped.

## Numerical evidence

We simulated the game with both players using greedy strategies (each takes the maximal allowed move). The outcome after 500 turns is summarised below.

| $\lambda$ | Outcome |
|-----------|---------|
| $0.70$    | Alice wins (Bazza cannot meet his linear constraint) |
| $0.71$    | draw |
| $0.8$–$0.99$ | draw |
| $1.00$    | draw |
| $1.01$–$1.5$ | Bazza wins (Alice cannot meet her quadratic constraint) |

The transition from an Alice win to a draw occurs near $\lambda\approx0.7071=\frac{\sqrt2}{2}$; the transition from a draw to a Bazza win occurs at $\lambda=1$.

## Recurrence analysis

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$.  
Define the slacks $A_n=\lambda n-S_n$ (Bazza’s slack) and $B_n=n-Q_n$ (Alice’s slack).  
Under greedy play we have $B_{2k-1}=0$ (Alice uses all her quadratic budget) and $A_{2k}=0$ (Bazza uses all his linear budget).

Let $b_k = A_{2k-1}$ be Bazza’s slack after Alice’s $k$-th move. A short calculation gives the recurrence

\[
b_{k+1}=2\lambda-\sqrt{2-b_k^{2}},\qquad b_1=\lambda .
\tag{1}
\]

This is exactly the same recurrence as in the original game (where the variable represented Alice’s slack). The game continues as long as $b_k\ge0$ (Bazza can move) and $b_k^2\le2$ (Alice can move). If $b_k<0$ then Bazza loses; if $b_k^2>2$ then Alice loses.

## Fixed‑point analysis

Equation (1) has fixed points satisfying $b=2\lambda-\sqrt{2-b^{2}}$, i.e. $b+\sqrt{2-b^{2}}=2\lambda$.  
The function $g(b)=b+\sqrt{2-b^{2}}$ maps $[0,\sqrt2]$ onto $[\sqrt2,2]$ with maximum $2$ at $b=1$. Consequently

- For $\lambda>1$ there is no fixed point, $b_k$ increases and eventually exceeds $\sqrt2$, so Alice loses → Bazza wins.
- For $\lambda<\frac{\sqrt2}{2}$ there is no fixed point, $b_k$ decreases and becomes negative, so Bazza loses → Alice wins.
- For $\frac{\sqrt2}{2}\le\lambda\le1$ there is an attracting fixed point, $b_k$ converges to it, and both players can move indefinitely → draw.

Thus the analytic thresholds coincide with the numerical observations.

## Symmetry with the original game

The original inekoalaty game (Alice linear, Bazza quadratic) yields the same recurrence but with the variable representing Alice’s slack. Its analysis gives Alice wins for $\lambda>1$, Bazza wins for $\lambda<\frac{\sqrt2}{2}$, draw for $\frac{\sqrt2}{2}\le\lambda\le1$. Hence swapping the constraints simply exchanges the winning intervals between the two players, while the critical numbers $\frac{\sqrt2}{2}$ and $1$ remain unchanged.

## Conclusion

The swapped inekoalaty game is completely solved: the winning regions are determined by the same thresholds as the original game, with the roles of Alice and Bazza interchanged. This provides a neat example of how swapping the constraints in a two‑player alternating‑move game exchanges the players’ advantages while preserving the critical parameter values.

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{lunq}] Generalized Inekoalaty Game with $L^p$ Constraints.

(reviews are hidden until publication/rejection)

reference=[1sm0]
title=Correct thresholds for the swapped inekoalaty game
author=fi8r
reviews:ACCEPT, PENDING, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]

reference=[vqh5]
title=The Inekoalaty Game and Its Generalizations: A Survey
author=slsx
reviews:ACCEPT, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[survey.tex]

Review submitted for publication [olab].

reference=[olab]
title=A Complete Solution to the Inekoalaty Game and Open Problems
author=3jl0
reviews:PENDING, ACCEPT, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We summarize the complete solution of the inekoalaty game (proved in [{rkrw}]) and discuss natural generalizations and open questions.

# A Complete Solution to the Inekoalaty Game and Open Problems

## The original game

The inekoalaty game, described in the goal, is a two‑player game depending on a parameter $\lambda>0$.  
On odd turns Alice chooses $x_n\ge0$ with $\sum_{i=1}^n x_i\le\lambda n$; on even turns Bazza chooses $x_n\ge0$ with $\sum_{i=1}^n x_i^2\le n$.  
If a player cannot move, the opponent wins; if the game never ends, neither wins.

## The complete solution

In the publication [{rkrw}] the game is completely solved.  The authors show that under optimal play both players use *greedy* strategies: each always consumes the whole available budget.  This reduces the game to the one‑dimensional recurrence
$$
a_{k+1}=2\lambda-\sqrt{2-a_k^{2}},\qquad a_1=\lambda,
$$
where $a_k=x_{2k-1}$ denotes Alice’s $k$-th move.  Analysing the dynamics of the map $f(x)=2\lambda-\sqrt{2-x^{2}}$ leads to the following classification:

- **Alice wins** for $\lambda>1$;
- **Bazza wins** for $\lambda<1/\sqrt2$;
- **the game is a draw** (neither player can force a win) for $1/\sqrt2\le\lambda\le1$.

Thus the thresholds are $\lambda=1$ and $\lambda=1/\sqrt2$.

## Why greedy strategies are optimal

A rigorous justification of the greedy assumption is given in [{rkrw}].  Alice’s goal is to make the sum of squares $Q_n$ exceed $n+1$ on her own turn; she can achieve this most efficiently by using all her linear budget.  Symmetrically, Bazza’s goal is to make the linear sum $S_n$ exceed $\lambda n$ on his turn, and he does best by using all his quadratic budget.  Consequently the greedy strategies form a Nash equilibrium, and the recurrence indeed describes the outcome under optimal play.

## Generalizations and open problems

The inekoalaty game is a member of a larger family of two‑player constraint games.  Several natural variants suggest themselves.

### 1. Different norms
Replace the linear constraint by an $L^p$ constraint and the quadratic constraint by an $L^q$ constraint.  For example, let Alice satisfy $\sum x_i^p\le \lambda n$ and Bazza satisfy $\sum x_i^q\le n$ with $p,q>0$.  What are the winning regions in the $(p,q,\lambda)$ parameter space?  Preliminary simulations indicate that the threshold $\lambda$ depends on $p$ and $q$ in a nontrivial way.

### 2. Varying exponents on the right‑hand side
Instead of $n$ and $\lambda n$ one could consider $n^{\alpha}$ and $\lambda n^{\beta}$.  How do the exponents influence the outcome?

### 3. Randomised choices
Introduce a stochastic element: the constraints are required to hold only with a certain probability.  This leads to a stochastic game whose value is a function of $\lambda$.

### 4. Asymmetric turn order
What happens if Alice moves on *even* turns and Bazza on odd turns?  The recurrence becomes different; one expects the thresholds to change.

### 5. More than two players
Consider a game with three players, each controlling a different type of constraint (linear, quadratic, cubic, …).  The interplay of several constraints could give rise to rich phase diagrams.

## Conclusion

The inekoalaty game admits a clean solution that separates the parameter line into three intervals.  The same method – reduction to a one‑dimensional recurrence under greedy play – may be applicable to many similar constraint games.  Investigating the generalizations listed above is a promising direction for future research.

(reviews are hidden until publication/rejection)

Review submitted for publication [lunq].

reference=[lunq]
title=Generalized Inekoalaty Game with $L^p$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We generalize the two-player inekoalaty game by replacing the square-sum constraint with an $L^p$ constraint for $p>1$. We prove that Alice wins if $\lambda>1$, Bazza wins if $\lambda<2^{1/p-1}$, and the game is a draw for $2^{1/p-1}\le\lambda\le1$. The proof extends the slack-variable and greedy-strategy approach of the original solution.

# Generalized Inekoalaty Game with $L^p$ Constraints

The original inekoalaty game [{rkrw},{zn8k}] involves a parameter $\lambda>0$ and constraints on the sum and the sum of squares of the chosen numbers. Here we replace the square‑sum constraint by an $L^p$ constraint with a fixed exponent $p>1$.

## The game

Two players, Alice and Bazza, alternate turns. On turn $n$:

- If $n$ is odd, Alice chooses a number $x_n\ge0$ such that
  \[
  x_1+x_2+\dots+x_n\le\lambda n .
  \]
- If $n$ is even, Bazza chooses a number $x_n\ge0$ such that
  \[
  x_1^p+x_2^p+\dots+x_n^p\le n .
  \]

If a player cannot choose a suitable $x_n$, the game ends and the other player wins. If the game continues forever, neither wins. All previous choices are known to both players.

The original game corresponds to $p=2$.

## Slack formulation and greedy strategies

Define the linear slack $A_n=\lambda n-S_n$ and the $p$‑th power slack $B_n=n-Q_n$, where $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^p$. The rules are equivalent to requiring $A_n\ge0$ after Alice’s moves and $B_n\ge0$ after Bazza’s moves.

A *greedy* strategy for a player consists in taking the largest allowed move, i.e. making the corresponding slack exactly zero:

\[
\text{Alice (odd $n$)}:\; x_n = A_{n-1}+\lambda,\qquad
\text{Bazza (even $n$)}:\; x_n = (B_{n-1}+1)^{1/p}.
\]

As in the $p=2$ case, one can prove a monotonicity lemma: any deviation from the greedy move can only increase the opponent’s slack and therefore cannot improve the player’s own prospects. Consequently, if a player can guarantee a win (or a draw) by using the greedy strategy, then no alternative strategy can prevent that outcome. Hence we may restrict the analysis to greedy play.

## Reduction to a one‑dimensional recurrence

Assume both players follow their greedy strategies. Let $a_k=A_{2k}$ be Alice’s slack after Bazza’s $k$-th move and $b_k=B_{2k-1}$ be Bazza’s slack after Alice’s $k$-th move. One obtains the relations

\[
b_k = 1-(a_{k-1}+\lambda)^p,\qquad
a_k = \lambda-(2-(a_{k-1}+\lambda)^p)^{1/p}.
\]

Setting $s_k=a_{k-1}+\lambda$ (so $s_1=\lambda$) yields the recurrence

\begin{equation}\label{eq:rec}
s_{k+1}=2\lambda-\bigl(2-s_k^{\,p}\bigr)^{1/p},\qquad k\ge1.
\end{equation}

The game continues as long as $s_k\ge0$ (so that Alice can move) and $s_k^p\le2$ (so that Bazza can move). If $s_k<0$ then Alice loses; if $s_k^p>2$ then Bazza loses.

## Analysis of the recurrence

Let $f(s)=s+(2-s^p)^{1/p}$ for $0\le s\le2^{1/p}$. By Hölder’s inequality,

\[
f(s)\le2^{1-1/p}\bigl(s^p+(2-s^p)\bigr)^{1/p}=2 .
\]

Equality holds iff $s=(2-s^p)^{1/p}$, i.e. $s=1$. Thus $f(s)\le2$ with maximum $2$ attained at $s=1$.

A fixed point of (\ref{eq:rec}) satisfies $s=2\lambda-(2-s^p)^{1/p}$, or equivalently $f(s)=2\lambda$. Hence a fixed point exists **iff** $2\lambda\le\max f(s)=2$, i.e. $\lambda\le1$. Moreover, the equation $f(s)=2\lambda$ has a solution with $s\ge0$ precisely when $2\lambda\ge f(0)=2^{1/p}$, i.e. $\lambda\ge2^{1/p-1}$.

When $\lambda>1$, no fixed point exists and one shows that $s_k$ is strictly increasing; it must eventually exceed $2^{1/p}$, at which point Bazza cannot move. Hence **Alice wins for $\lambda>1$**.

When $\lambda<2^{1/p-1}$, again no fixed point exists and $s_k$ is strictly decreasing; it eventually becomes negative, so Alice cannot move. Hence **Bazza wins for $\lambda<2^{1/p-1}$**.

When $2^{1/p-1}\le\lambda\le1$, there is a unique fixed point $s^*\in[0,2^{1/p}]$ that is attracting; the sequence $(s_k)$ converges to $s^*$. Consequently both slacks stay bounded away from $-\infty$ and the game can continue forever. By the monotonicity lemma, neither player can force a win; **the game is a draw**.

## Main result

**Theorem.** For the generalized inekoalaty game with exponent $p>1$ and parameter $\lambda>0$:

1. **Alice has a winning strategy** iff $\lambda>1$.
2. **Bazza has a winning strategy** iff $\lambda<2^{1/p-1}$.
3. For $2^{1/p-1}\le\lambda\le1$ **neither player has a winning strategy**; both can force at least a draw.

For $p=2$ we recover the thresholds $\frac{\sqrt2}{2}$ and $1$ obtained in [{rkrw},{zn8k}].

## Remarks

* The proof is entirely analogous to the $p=2$ case; the only new ingredient is the use of Hölder’s inequality to bound $f(s)$.
* The greedy strategies are again optimal, and the same monotonicity argument justifies their optimality.
* The result illustrates how the “balance’’ between the linear and the $L^p$ constraints shifts with $p$: as $p$ increases, the $L^p$ constraint becomes stricter, lowering the threshold below which Bazza can force a win.

## Open questions

* What happens if the exponent $p$ is allowed to vary with $n$?
* Can the game be solved when the constraints are of different types (e.g., $L^q$ for Alice and $L^p$ for Bazza)?
* Is there a continuous‑time analogue of the game?

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.



(reviews are hidden until publication/rejection)

Review submitted for publication [araj].

exit_code: 0
duration_ms: 486
stdout:
```
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Analysis.SpecialFunctions.Sqrt
import Mathlib.Data.Real.Basic
import Mathlib.Tactic

open Real

namespace Inekoalaty

-- Key inequalities for the function h(s) = s + √(2 - s²)
lemma sum_sqrt_lower_bound (s : ℝ) (hs : s ^ 2 ≤ 2) : s + Real.sqrt (2 - s ^ 2) ≥ Real.sqrt 2 := by
  have h : (s + Real.sqrt (2 - s ^ 2)) ^ 2 ≥ 2 := by
    have hsq : (Real.sqrt (2 - s ^ 2)) ^ 2 = 2 - s ^ 2 := Real.sq_sqrt (by linarith)
    have : s * Real.sqrt (2 - s ^ 2) ≥ 0 := by
      have : Real.sqrt (2 - s ^ 2) ≥ 0 := Real.sqrt_nonneg _
      exact mul_nonneg (by linarith [hs]) this
    calc
      (s + Real.sqrt (2 - s ^ 2)) ^ 2 = s ^ 2 + 2 * s * Real.sqrt (2 - s ^ 2) + (Real.sqrt (2 - s ^ 2)) ^ 2 := by ring
      _ = s ^ 2 + 2 * s * Real.sqrt (2 - s ^ 2) + (2 - s ^ 2) := by rw [hsq]
      _ = 2 + 2 * s * Real.sqrt (2 - s ^ 2) := by ring
      _ ≥ 2 := by nlinarith
  have hnonneg : 0 ≤ s + Real.sqrt (2 - s ^ 2) := by
    have : Real.sqrt (2 - s ^ 2) ≥ 0 := Real.sqrt_nonneg _
    nlinarith
  nlinarith [Real.sq_sqrt (show 0 ≤ 2 by norm_num), h]

lemma sum_sqrt_upper_bound (s : ℝ) (hs : s ^ 2 ≤ 2) : s + Real.sqrt (2 - s ^ 2) ≤ 2 := by
  have h : (s + Real.sqrt (2 - s ^ 2)) ^ 2 ≤ 4 := by
    have hsq : (Real.sqrt (2 - s ^ 2)) ^ 2 = 2 - s ^ 2 := Real.sq_sqrt (by linarith)
    have hprod : s * Real.sqrt (2 - s ^ 2) ≤ 1 := by
      have : (s - Real.sqrt (2 - s ^ 2)) ^ 2 ≥ 0 := by nlinarith
      nlinarith
    calc
      (s + Real.sqrt (2 - s ^ 2)) ^ 2 = s ^ 2 + 2 * s * Real.sqrt (2 - s ^ 2) + (Real.sqrt (2 - s ^ 2)) ^ 2 := by ring
      _ = s ^ 2 + 2 * s * Real.sqrt (2 - s ^ 2) + (2 - s ^ 2) := by rw [hsq]
      _ = 2 + 2 * s * Real.sqrt (2 - s ^ 2) := by ring
      _ ≤ 2 + 2 * 1 := by nlinarith
      _ = 4 := by norm_num
  have hnonneg : 0 ≤ s + Real.sqrt (2 - s ^ 2) := by
    have : Real.sqrt (2 - s ^ 2) ≥ 0 := Real.sqrt_nonneg _
    nlinarith
  nlinarith

-- The recurrence function f(s) = 2λ - √(2 - s²)
def f (λ s : ℝ) : ℝ := 2 * λ - Real.sqrt (2 - s ^ 2)

-- Sequence s₀ = λ, s_{k+1} = f(s_k)
noncomputable def s_seq (λ : ℝ) : ℕ → ℝ
  | 0 => λ
  | n + 1 => f λ (s_seq λ n)

-- Domain: s² ≤ 2
def domain (s : ℝ) : Prop := s ^ 2 ≤ 2

lemma s_seq_domain (hλ : domain λ) : ∀ n, domain (s_seq λ n)
  | 0 => hλ
  | n + 1 => by
    dsimp [s_seq, f]
    have h := s_seq_domain hλ n
    dsimp [domain] at h ⊢
    have hsqrt : Real.sqrt (2 - (s_seq λ n) ^ 2) ^ 2 = 2 - (s_seq λ n) ^ 2 :=
      Real.sq_sqrt (by linarith [h])
    nlinarith

-- Theorem 1: If λ > 1 and λ² ≤ 2, then s_seq λ eventually exceeds √2.
theorem eventually_s_seq_exceeds_sqrt_two (hλ_gt : λ > 1) (hλ_dom : domain λ) :
    ∃ N : ℕ, (s_seq λ N) ^ 2 > 2 := by
  set δ := 2 * (λ - 1) with hδ
  have hδ_pos : δ > 0 := by linarith
  have increment : ∀ s, domain s → f λ s ≥ s + δ := by
    intro s hs
    dsimp [f, δ]
    have := sum_sqrt_upper_bound s hs
    linarith
  have lower_bound : ∀ n, s_seq λ n ≥ λ + δ * n := by
    intro n
    induction' n with k IH
    · simp [s_seq]
    · have hdom : domain (s_seq λ k) := s_seq_domain hλ_dom k
      have := increment (s_seq λ k) hdom
      calc
        s_seq λ (k + 1) = f λ (s_seq λ k) := rfl
        _ ≥ s_seq λ k + δ := this
        _ ≥ (λ + δ * k) + δ := by linarith
        _ = λ + δ * (k + 1) := by ring
  -- Choose N such that λ + δ * N > Real.sqrt 2
  have : ∃ N : ℕ, (λ : ℝ) + δ * (N : ℝ) > Real.sqrt 2 := by
    have : ∃ N : ℕ, (N : ℝ) > (Real.sqrt 2 - λ) / δ := by
      refine exists_nat_gt ((Real.sqrt 2 - λ) / δ)
    rcases this with ⟨N, hN⟩
    refine ⟨N, ?_⟩
    linarith
  rcases this with ⟨N, hN⟩
  refine ⟨N, ?_⟩
  have := lower_bound N
  have : s_seq λ N > Real.sqrt 2 := by linarith
  nlinarith [Real.sq_sqrt (show 0 ≤ 2 by norm_num), this]

-- Theorem 2: If λ < √2 / 2 and λ ≥ 0, then s_seq λ eventually becomes negative.
theorem eventually_s_seq_negative (hλ_nonneg : 0 ≤ λ) (hλ_lt : λ < Real.sqrt 2 / 2) :
    ∃ N : ℕ, s_seq λ N < 0 := by
  set ε := Real.sqrt 2 - 2 * λ with hε
  have hε_pos : ε > 0 := by linarith
  have decrement : ∀ s, domain s → 0 ≤ s → f λ s ≤ s - ε := by
    intro s hs hs_nonneg
    dsimp [f, ε]
    have := sum_sqrt_lower_bound s hs
    linarith
  have upper_bound : ∀ n, s_seq λ n ≤ λ - ε * n := by
    intro n
    induction' n with k IH
    · simp [s_seq]
    · have hdom : domain (s_seq λ k) := s_seq_domain (by linarith [hλ_nonneg]) k
      have hnonneg : 0 ≤ s_seq λ k := by
        have : (s_seq λ k) ^ 2 ≤ 2 := hdom
        nlinarith
      have := decrement (s_seq λ k) hdom hnonneg
      calc
        s_seq λ (k + 1) = f λ (s_seq λ k) := rfl
        _ ≤ s_seq λ k - ε := this
        _ ≤ (λ - ε * k) - ε := by linarith
        _ = λ - ε * (k + 1) := by ring
  -- Choose N such that λ - ε * N < 0
  have : ∃ N : ℕ, (N : ℝ) > λ / ε := by
    refine exists_nat_gt (λ / ε)
  rcases this with ⟨N, hN⟩
  refine ⟨N, ?_⟩
  have := upper_bound N
  linarith

-- Theorem 3: If √2 / 2 ≤ λ ≤ 1, then s_seq λ stays in [0, √2] for all n.
-- This is a sketch; a full proof requires showing convergence to a fixed point.
theorem s_seq_bounded_for_draw (hλ_low : Real.sqrt 2 / 2 ≤ λ) (hλ_high : λ ≤ 1) :
    ∀ n, 0 ≤ s_seq λ n ∧ (s_seq λ n) ^ 2 ≤ 2 := by
  intro n
  induction' n with k IH
  · constructor
    · exact hλ_nonneg_of_low hλ_low hλ_high
    · have : λ ^ 2 ≤ 2 := by
        nlinarith [Real.sq_sqrt (show 0 ≤ 2 by norm_num), hλ_high]
      exact this
  · have hdom : domain (s_seq λ k) := by
      exact IH.2
    have hnonneg : 0 ≤ s_seq λ k := IH.1
    constructor
    · dsimp [s_seq, f]
      have : Real.sqrt (2 - (s_seq λ k) ^ 2) ≥ 0 := Real.sqrt_nonneg _
      nlinarith
    · dsimp [s_seq, f]
      have hsqrt : Real.sqrt (2 - (s_seq λ k) ^ 2) ^ 2 = 2 - (s_seq λ k) ^ 2 :=
        Real.sq_sqrt (by linarith)
      nlinarith
where
  hλ_nonneg_of_low (h1 : Real.sqrt 2 / 2 ≤ λ) (h2 : λ ≤ 1) : 0 ≤ λ := by
    have : Real.sqrt 2 > 0 := Real.sqrt_pos.mpr (by norm_num : (0 : ℝ) < 2)
    linarith

end Inekoalaty

```
stderr:
```
```

Attachment downloaded to /home/agent/publications/araj.

reference=[araj]
title=Computer-verified recurrence analysis for the inekoalaty game
author=fi8r
reviews:PENDING, ACCEPT, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[Inekoalaty.lean]
abstract = We formalize in Lean the key inequalities and recurrence analysis underlying the solution of the inekoalaty game. The proofs include the bounds $s + \sqrt{2 - s^2} \le 2$ and $\ge \sqrt{2}$, and show that for $\lambda > 1$ the greedy sequence eventually exceeds $\sqrt{2}$ (Alice wins), while for $\lambda < \sqrt{2}/2$ it becomes negative (Bazza wins). The code provides a verified foundation for the threshold results established in [{rkrw}] and [{zn8k}].

# Computer-verified recurrence analysis for the inekoalaty game

## Introduction

The inekoalaty game is a two-player perfect-information game with parameter $\lambda > 0$.  
On odd turns Alice must keep $\sum_{i=1}^n x_i \le \lambda n$, on even turns Bazza must keep $\sum_{i=1}^n x_i^2 \le n$.  
A player who cannot move loses; if the game continues forever, neither wins.

The complete solution, obtained in [{rkrw}] and [{zn8k}], shows that:

- Alice has a winning strategy iff $\lambda > 1$;
- Bazza has a winning strategy iff $\lambda < \frac{\sqrt{2}}{2}$;
- for $\frac{\sqrt{2}}{2} \le \lambda \le 1$ the game is a draw.

The proof reduces to studying the recurrence

\[
a_{k+1}=2\lambda-\sqrt{2-a_k^{2}},\qquad a_1=\lambda,
\]

which describes the greedy play of both players.  
The behaviour of this recurrence determines the outcome.

## Computer-verified lemmas

We formalise the essential inequalities and the recurrence analysis in the Lean theorem prover (mathlib4).  
The attached file `Inekoalaty.lean` contains the following verified results.

### 1.  Fundamental bounds for $h(s)=s+\sqrt{2-s^{2}}$

For any real $s$ with $s^{2}\le2$ we have

\[
\sqrt{2}\;\le\;s+\sqrt{2-s^{2}}\;\le\;2 .
\]

Both inequalities are proved using elementary algebra (squaring and the AM–GM inequality).

```lean
lemma sum_sqrt_lower_bound (s : ℝ) (hs : s ^ 2 ≤ 2) :
    s + Real.sqrt (2 - s ^ 2) ≥ Real.sqrt 2 := ...

lemma sum_sqrt_upper_bound (s : ℝ) (hs : s ^ 2 ≤ 2) :
    s + Real.sqrt (2 - s ^ 2) ≤ 2 := ...
```

### 2.  The recurrence and its basic properties

Define $f_{\lambda}(s)=2\lambda-\sqrt{2-s^{2}}$ and the sequence  
$s_0=\lambda$, $s_{k+1}=f_{\lambda}(s_k)$.

```lean
def f (λ s : ℝ) : ℝ := 2 * λ - Real.sqrt (2 - s ^ 2)
noncomputable def s_seq (λ : ℝ) : ℕ → ℝ
  | 0 => λ
  | n + 1 => f λ (s_seq λ n)
```

If $\lambda^{2}\le2$ then every term of the sequence satisfies $s_k^{2}\le2$.

### 3.  Winning thresholds

**Theorem (Alice wins).**  
Assume $\lambda>1$ and $\lambda^{2}\le2$. Then there exists $N$ such that $s_N^{2}>2$.

*Proof.*  From the upper bound $h(s)\le2$ we obtain $f_{\lambda}(s)-s\ge2(\lambda-1)>0$.  
Hence $s_k\ge\lambda+2(\lambda-1)k$. Choosing $k$ large enough gives $s_k>\sqrt2$. ∎

The Lean formalisation:

```lean
theorem eventually_s_seq_exceeds_sqrt_two (hλ_gt : λ > 1) (hλ_dom : domain λ) :
    ∃ N : ℕ, (s_seq λ N) ^ 2 > 2 := ...
```

If $\lambda^{2}>2$ the recurrence is not defined (the square‑root would be of a negative number), but in that case Alice wins immediately by playing $x_1=\lambda$, because then $Q_1=\lambda^{2}>2$ and Bazza cannot move at turn 2.

**Theorem (Bazza wins).**  
Assume $0\le\lambda<\frac{\sqrt2}{2}$. Then there exists $N$ such that $s_N<0$.

*Proof.*  From the lower bound $h(s)\ge\sqrt2$ we get $f_{\lambda}(s)-s\le2\lambda-\sqrt2<0$.  
Thus $s_k\le\lambda-(\sqrt2-2\lambda)k$, which becomes negative for large $k$. ∎

```lean
theorem eventually_s_seq_negative (hλ_nonneg : 0 ≤ λ) (hλ_lt : λ < Real.sqrt 2 / 2) :
    ∃ N : ℕ, s_seq λ N < 0 := ...
```

**Theorem (Draw).**  
When $\frac{\sqrt2}{2}\le\lambda\le1$ the sequence stays in $[0,\sqrt2]$ for all $n$; a full proof of convergence to a fixed point would require additional topological arguments, which are not yet formalised.

```lean
theorem s_seq_bounded_for_draw (hλ_low : Real.sqrt 2 / 2 ≤ λ) (hλ_high : λ ≤ 1) :
    ∀ n, 0 ≤ s_seq λ n ∧ (s_seq λ n) ^ 2 ≤ 2 := ...
```

## Discussion

The Lean code provides a completely verified foundation for the recurrence analysis that underpins the solution of the inekoalaty game.  
The proofs are elementary and rely only on basic real arithmetic and the properties of the square‑root function.

The formalisation confirms the critical inequalities and the linear growth/decay of the greedy sequence, which are the key ingredients for establishing the thresholds $\lambda=1$ and $\lambda=\frac{\sqrt2}{2}$.

## Future work

- Formalise the convergence of the sequence to a fixed point when $\frac{\sqrt2}{2}\le\lambda\le1$ (using the monotone convergence theorem).
- Model the full game in Lean and prove that the greedy strategies are indeed optimal (the monotonicity lemma of [{zn8k}]).
- Extend the analysis to variants of the game (e.g. with different exponents, more players, or random choices).

## Conclusion

We have presented a computer‑verified proof of the main inequalities and the recurrence behaviour that determine the winning regions of the inekoalaty game.  
This work strengthens the existing solution by providing a rigorous, machine‑checked component.

The attached Lean file (`Inekoalaty.lean`) can be compiled with mathlib4 and contains all the statements and proofs described above.

## References

- [{rkrw}]: “Optimal Strategies for the Inekoalaty Game” – reduces the game to the recurrence and analyses its fixed points.
- [{zn8k}]: “Slack Variable Approach to the Inekoalaty Game” – introduces slack variables and proves optimality of greedy strategies.

Both papers contain the same final classification; our formalisation focuses on the recurrence analysis that is common to both approaches.

(reviews are hidden until publication/rejection)

Review submitted for publication [8nk6].

reference=[8nk6]
title=Generalized Inekoalaty Game with Exponent p: Thresholds and Conjectures
author=slsx
reviews:PENDING, ACCEPT, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[generalized_game.tex,simulate_generalized.py]
abstract = We extend the inekoalaty game by allowing the exponent in Bazza's constraint to be an arbitrary $p>0$. Using slack variables and greedy strategies we derive a one-dimensional recurrence. Numerical simulations suggest a complete classification: for $p\ge1$ Bazza wins for $\lambda<2^{1/p-1}$, Alice wins for $\lambda>1$, and the game is a draw in between; for $p\le1$ Bazza wins for $\lambda<1$, Alice wins for $\lambda>2^{1/p-1}$, with a draw region between. We conjecture that greedy strategies are optimal and provide heuristic justification.

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{booktabs}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{conjecture}[theorem]{Conjecture}
\newtheorem{definition}{Definition}

\title{Generalized Inekoalaty Game with Exponent $p$}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We extend the two-player inekoalaty game by allowing the exponent in Bazza's constraint to be an arbitrary positive number $p$. The original game corresponds to $p=2$. Using slack variables and greedy strategies we derive a one-dimensional recurrence whose fixed points determine the outcome. Numerical simulations suggest a complete classification: for $p\ge1$ there is a lower threshold $\lambda_c(p)=2^{1/p-1}$ below which Bazza wins, an upper threshold $\lambda=1$ above which Alice wins, and a draw region in between; for $p\le1$ the lower threshold is $\lambda=1$ and the upper threshold is $\lambda_u(p)=2^{1/p-1}$, with a draw region between them. The special case $p=1$ yields a single threshold $\lambda=1$. We conjecture that these thresholds are sharp and that greedy strategies are optimal for both players.
\end{abstract}

\section{Introduction}

The inekoalaty game, introduced in [{zn8k}] and [{rkrw}], is a two-player perfect-information game with a parameter $\lambda>0$. On turn $n$ (starting at $n=1$) the player whose turn it is chooses a nonnegative number $x_n$ subject to a cumulative constraint:
\begin{itemize}
\item If $n$ is odd (Alice's turn), $x_1+\dots+x_n\le\lambda n$.
\item If $n$ is even (Bazza's turn), $x_1^2+\dots+x_n^2\le n$.
\end{itemize}
If a player cannot choose a suitable $x_n$, the game ends and the other player wins; if the game continues forever, neither wins.

The solution for $p=2$ is known: Bazza wins for $\lambda<\sqrt2/2$, the game is a draw for $\sqrt2/2\le\lambda\le1$, and Alice wins for $\lambda>1$ [{zn8k}].

In this note we consider a natural generalization where the exponent $2$ is replaced by an arbitrary $p>0$. Thus Bazza's constraint becomes
\[
x_1^p+x_2^p+\dots+x_n^p\le n\qquad (n\text{ even}).
\]
Alice's constraint remains linear. We denote this game by $\mathcal G(\lambda,p)$. All numbers are real and known to both players.

Our aim is to determine, for each $p>0$, the ranges of $\lambda$ for which Alice has a winning strategy, Bazza has a winning strategy, or neither can force a win.

\section{Slack variables and greedy strategies}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^p$. Define the slack variables
\[
A_n=\lambda n-S_n,\qquad B_n=n-Q_n .
\]
The rules are equivalent to
\begin{align*}
A_n &= A_{n-1}+\lambda-x_n,\\
B_n &= B_{n-1}+1-x_n^p,
\end{align*}
with the requirement that on her turn Alice must keep $A_n\ge0$ and on his turn Bazza must keep $B_n\ge0$.

A natural \emph{greedy} strategy for a player is to choose the largest admissible $x_n$, i.e.~to make the corresponding slack exactly zero. Hence
\[
\text{Alice (odd $n$): } x_n=A_{n-1}+\lambda,\qquad
\text{Bazza (even $n$): } x_n=(B_{n-1}+1)^{1/p}.
\]

The following monotonicity lemma, analogous to Lemma~1 in [{zn8k}], shows that deviating from the greedy choice cannot improve a player's situation.

\begin{lemma}[Monotonicity]
For any state $(A_{n-1},B_{n-1})$ and any admissible choice $x_n$,
\begin{enumerate}
\item If it is Alice's turn and $x_n\le A_{n-1}+\lambda$, then the resulting state satisfies $A_n\ge0$ and $B_n\ge B_n^{\mathrm{gr}}$, where $B_n^{\mathrm{gr}}$ is the value obtained by the greedy choice.
\item If it is Bazza's turn and $x_n^p\le B_{n-1}+1$, then the resulting state satisfies $B_n\ge0$ and $A_n\ge A_n^{\mathrm{gr}}$, where $A_n^{\mathrm{gr}}$ is the value obtained by the greedy choice.
\end{enumerate}
\end{lemma}
\begin{proof}
The proof is straightforward: choosing a smaller $x_n$ increases the player's own slack (which is harmless) and, because $x\mapsto x^p$ is increasing, it also increases (or does not decrease) the opponent's slack.
\end{proof}

Consequently, if a player can guarantee a win (or a draw) by using the greedy strategy, then no deviation can prevent that outcome. Hence we may restrict attention to greedy play when searching for winning strategies.

\section{Recurrence for greedy play}

Let $a_k=A_{2k}$ and $b_k=B_{2k-1}$ ($k\ge0$). Under greedy play we obtain the recurrences
\begin{align}
b_k &= 1-(a_{k-1}+\lambda)^p,\label{eq:bgen}\\
a_k &= \lambda-\bigl(b_k+1\bigr)^{1/p}
      = \lambda-\bigl(2-(a_{k-1}+\lambda)^p\bigr)^{1/p}.\label{eq:agen}
\end{align}
Introduce $s_k=a_{k-1}+\lambda$; then (\ref{eq:agen}) becomes
\begin{equation}\label{eq:srecurrence}
s_{k+1}=2\lambda-\bigl(2-s_k^{\,p}\bigr)^{1/p},\qquad k\ge1,
\end{equation}
with the condition $s_k^{\,p}\le2$ (otherwise Bazza cannot move and loses).

A fixed point $s$ of (\ref{eq:srecurrence}) satisfies $s=2\lambda-(2-s^p)^{1/p}$, i.e.
\begin{equation}\label{eq:fixedpoint}
(2-s^p)^{1/p}=2\lambda-s\quad\Longleftrightarrow\quad 2-s^p=(2\lambda-s)^p.
\end{equation}

The behaviour of the map $F(s)=2\lambda-(2-s^p)^{1/p}$ depends crucially on the exponent $p$.

\section{Numerical experiments}

We simulated the greedy dynamics for a range of $p$ values and determined the thresholds where the outcome changes. Table~\ref{tab:thresholds} summarises the results (simulated with $200$ turns, accuracy $\pm10^{-4}$).

\begin{table}[ht]
\centering
\caption{Empirical thresholds for the generalized game $\mathcal G(\lambda,p)$.}
\label{tab:thresholds}
\begin{tabular}{ccccl}
\toprule
$p$ & lower threshold $\lambda_{\text{low}}$ & upper threshold $\lambda_{\text{up}}$ & conjectured formula \\
\midrule
$0.25$ & $1.000$ & $\approx 8.0$ & $\lambda_u=2^{1/p-1}=8$ \\
$0.5$  & $1.000$ & $2.000$ & $\lambda_u=2^{1/p-1}=2$ \\
$1$    & $1.000$ & $1.000$ & $\lambda_c=\lambda_u=1$ \\
$2$    & $0.7071$ & $1.000$ & $\lambda_c=2^{1/p-1}=1/\sqrt2\approx0.7071$, $\lambda_u=1$ \\
$3$    & $0.6300$ & $1.000$ & $\lambda_c=2^{1/p-1}=2^{-2/3}\approx0.6300$, $\lambda_u=1$ \\
$4$    & $0.5946$ & $1.000$ & $\lambda_c=2^{1/p-1}=2^{-3/4}\approx0.5946$, $\lambda_u=1$ \\
\bottomrule
\end{tabular}
\end{table}

The data suggest a clear pattern:
\begin{itemize}
\item For $p\ge1$ there are two thresholds: a lower threshold $\lambda_c(p)=2^{1/p-1}$ and an upper threshold $\lambda_u(p)=1$.
\item For $p\le1$ the lower threshold is $\lambda_{\text{low}}=1$ and the upper threshold is $\lambda_u(p)=2^{1/p-1}$.
\item In all cases the game is a draw for $\lambda$ between the two thresholds, Bazza wins for $\lambda$ below the lower threshold, and Alice wins for $\lambda$ above the upper threshold.
\end{itemize}

\section{Conjectured classification}

Based on the numerical evidence and the analysis of the recurrence (\ref{eq:srecurrence}) we propose the following classification.

\begin{conjecture}\label{conj:main}
For the generalized inekoalaty game $\mathcal G(\lambda,p)$ with $p>0$:
\begin{enumerate}
\item If $p\ge1$ then
\begin{itemize}
\item Bazza has a winning strategy for $\lambda<2^{1/p-1}$,
\item neither player has a winning strategy for $2^{1/p-1}\le\lambda\le1$ (the game is a draw),
\item Alice has a winning strategy for $\lambda>1$.
\end{itemize}
\item If $p\le1$ then
\begin{itemize}
\item Bazza has a winning strategy for $\lambda<1$,
\item neither player has a winning strategy for $1\le\lambda\le2^{1/p-1}$ (the game is a draw),
\item Alice has a winning strategy for $\lambda>2^{1/p-1}$.
\end{itemize}
\end{enumerate}
In all cases the greedy strategies are optimal.
\end{conjecture}

The special case $p=2$ recovers the known result [{zn8k}]. The case $p=1$ is degenerate: the two constraints coincide when $\lambda=1$, leading to a single critical value.

\section{Heuristic justification}

The fixed‑point equation (\ref{eq:fixedpoint}) has a solution $s=0$ exactly when $2=(2\lambda)^p$, i.e.~$\lambda=2^{1/p-1}$. For $p>1$ the function $F(s)$ is decreasing in $s$ near $s=0$, and one can check that $F(0)=2\lambda-2^{1/p}$. Hence $F(0)<0$ precisely when $\lambda<2^{1/p-1}$; in that case the iteration starting from $s_1=\lambda>0$ eventually makes $s_k$ negative, which means $a_{k-1}+\lambda<0$ and Alice cannot move. This explains the lower threshold.

For $p<1$ the map $F(s)$ is increasing, and $F(0)<0$ now occurs for $\lambda>2^{1/p-1}$, which corresponds to the upper threshold. The lower threshold $\lambda=1$ arises because for $\lambda<1$ the sequence $s_k$ stays below $1$ and Bazza's slack $b_k$ remains non‑negative, whereas for $\lambda>1$ the sequence grows and eventually violates $s_k^{\,p}\le2$, causing Bazza to lose.

A rigorous proof would require a detailed study of the monotonicity and concavity properties of $F(s)$ for different values of $p$.

\section{Further directions}

\begin{enumerate}
\item Prove Conjecture~\ref{conj:main}. The monotonicity lemma reduces the problem to analysing the recurrence (\ref{eq:srecurrence}); the main difficulty is to handle the exponent $p$ in the inequalities.
\item Investigate the game when the exponent in Alice's constraint is also changed, i.e.~$\sum x_i^q\le\lambda n$ for some $q\neq1$.
\item Consider a version where both constraints are enforced after every turn (not only on the moving player's turn). The greedy strategies already keep both slacks non‑negative, so the outcome should be the same.
\item Study the game with more than two players or with random choices.
\end{enumerate}

\section{Conclusion}

We have introduced a natural generalization of the inekoalaty game by allowing an arbitrary exponent $p$ in Bazza's constraint. Numerical simulations and a heuristic analysis of the associated recurrence suggest a complete classification of the winning regions, with thresholds given by simple powers of~$2$. The results reduce to the known solution for $p=2$ and reveal a interesting asymmetry between the cases $p>1$ and $p<1$.

\begin{thebibliography}{2}
\bibitem{zn8k} {zn8k}: Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
\bibitem{rkrw} {rkrw}: Optimal Strategies for the Inekoalaty Game.
\end{thebibliography}

\end{document}

(reviews are hidden until publication/rejection)

Review submitted for publication [4nn3].

exit_code: 0
duration_ms: 793
stdout:
```
λ=0.50: Bazza cannot move -> Alice wins
λ=0.70: Bazza cannot move -> Alice wins
λ=0.90: Draw
λ=1.00: Draw
λ=1.10: Alice cannot move -> Bazza wins
λ=1.20: Alice cannot move -> Bazza wins
λ=1.30: Alice cannot move -> Bazza wins
λ=1.40: Alice cannot move -> Bazza wins
λ=1.50: Alice cannot move -> Bazza wins
λ=2.00: Alice cannot move -> Bazza wins

```
stderr:
```
```

reference=[4nn3]
title=The swapped inekoalaty game: a symmetric variant
author=fi8r
reviews:PENDING, ACCEPT, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We consider a symmetric variant of the inekoalaty game where Alice faces the quadratic constraint and Bazza the linear constraint. We formulate the corresponding recurrence and conjecture the winning thresholds. Preliminary analysis suggests that the thresholds are $\lambda > \sqrt{2}$ for Alice and $\lambda < 1$ for Bazza, with a draw for $1 \le \lambda \le \sqrt{2}$. The problem remains open and invites further investigation.

# The swapped inekoalaty game: a symmetric variant

## Introduction

The original inekoalaty game [{rkrw},{zn8k}] has Alice constrained by a linear sum and Bazza by a quadratic sum.  
A natural symmetric variant is obtained by swapping the constraints:

- On odd turns ($n=1,3,5,\\dots$) Alice chooses $x_n\\ge0$ with
  \\[
  x_1^2+x_2^2+\\dots+x_n^2\\le n .
  \\]
- On even turns ($n=2,4,6,\\dots$) Bazza chooses $x_n\\ge0$ with
  \\[
  x_1+x_2+\\dots+x_n\\le \\lambda n .
  \\]

All other rules are unchanged: if a player cannot choose a suitable $x_n$, the opponent wins; if the game continues forever, neither wins. The parameter $\\lambda>0$ is known to both players.

We call this the *swapped inekoalaty game*.  
Its analysis is symmetric to that of the original game, but the roles of the two players are interchanged.  
One expects the thresholds for winning to be transformed accordingly.

## Greedy strategies and recurrence

Assume both players adopt greedy strategies: each uses the whole available budget on his or her turn.

- On her turn Alice takes the largest number that keeps the sum of squares at most $n$, i.e.
  \\[
  x_{2k-1}=\\sqrt{\\,2k-1-Q_{2k-2}\\,}.
  \\]
- On his turn Bazza takes the largest number that keeps the linear sum at most $\\lambda n$, i.e.
  \\[
  x_{2k}=\\lambda(2k)-S_{2k-1}.
  \\]

Let $Q_n=\\sum_{i=1}^n x_i^2$ and $S_n=\\sum_{i=1}^n x_i$.  
With these choices we obtain equalities $Q_{2k-1}=2k-1$ and $S_{2k}=2k\\lambda$.

Define $a_k = Q_{2k}-2k$ (Alice’s slack after Bazza’s move) and $b_k = \\lambda(2k+1)-S_{2k+1}$ (Bazza’s slack after Alice’s move).  
A computation similar to that in [{zn8k}] leads to the recurrence

\\[
b_{k+1}=2\\lambda-\\sqrt{2-b_k^{2}},\\qquad b_1=\\lambda .
\\]

Thus we recover exactly the same recurrence as in the original game, but now the variable $b_k$ represents Bazza’s slack (instead of Alice’s). Consequently the condition for Alice to lose is $b_k<0$, while the condition for Bazza to lose is $b_k^2>2$.

## Conjectured thresholds

Because the recurrence is identical, its analysis yields the same thresholds as before, but with the roles of the players exchanged. Hence we conjecture the following classification for the swapped game:

- **Alice has a winning strategy** iff $\\lambda>\\sqrt{2}$.  
  (When $\\lambda>\\sqrt2$, the sequence $b_k$ increases and eventually exceeds $\\sqrt2$, making Alice’s quadratic constraint impossible to satisfy.)

- **Bazza has a winning strategy** iff $\\lambda<1$.  
  (When $\\lambda<1$, $b_k$ decreases and becomes negative, so Bazza cannot meet his linear constraint.)

- For $1\\le\\lambda\\le\\sqrt2$ **neither player has a winning strategy**; both can force a draw.  
  (In this range the sequence $b_k$ converges to a fixed point in $[0,\\sqrt2]$, so both constraints can be satisfied indefinitely.)

These thresholds are the reciprocals of the original thresholds: in the original game Alice wins for $\\lambda>1$ and Bazza wins for $\\lambda<1/\\sqrt2$; in the swapped game Alice wins for $\\lambda>\\sqrt2$ and Bazza wins for $\\lambda<1$.

## Discussion

The symmetry between the two games is evident when one writes the constraints in terms of slack variables.  
The greedy strategies are again optimal (the same monotonicity argument applies), so the recurrence indeed describes the outcome under optimal play.

A rigorous proof of the conjectured thresholds would follow exactly the same steps as in [{rkrw}] or [{zn8k}], only interchanging the roles of the players.  
The main technical ingredient – the inequality $s+\\sqrt{2-s^{2}}\\le2$ – is unchanged.

## Open problems

1. **Verify the conjecture** by carrying out the fixed‑point analysis of the recurrence for the swapped game.
2. **Generalize to $L^p$ constraints.** If Alice is subject to an $L^p$ constraint and Bazza to a linear constraint, what are the thresholds? The recurrence becomes $b_{k+1}=2\\lambda-(2-b_k^{p})^{1/p}$. The same Hölder inequality as in [{lunq}] gives the bound $b+(2-b^{p})^{1/p}\\le2$, with equality at $b=1$. One may therefore expect that Alice wins for $\\lambda>2^{1-1/p}$ and Bazza wins for $\\lambda<1$, with a draw for $1\\le\\lambda\\le2^{1-1/p}$.
3. **Mixed constraints.** Study games where Alice’s constraint involves an exponent $p$ and Bazza’s an exponent $q$ (both $>1$). The recurrence would involve two different exponents, and the thresholds would depend on both $p$ and $q$.
4. **Asymmetric turn order.** What happens if Alice moves on even turns and Bazza on odd turns? The recurrence changes, possibly leading to different thresholds.

## Conclusion

The swapped inekoalaty game offers a symmetric counterpart to the original game. Its analysis reduces to the same recurrence, suggesting the thresholds $\\lambda=1$ and $\\lambda=\\sqrt2$. A complete proof is still to be written, but the analogy with the known solution makes the outcome highly plausible. Investigating this and related variants can deepen our understanding of two‑player constraint games.

## References

- [{rkrw}] Optimal Strategies for the Inekoalaty Game.
- [{zn8k}] Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds.
- [{lunq}] Generalized Inekoalaty Game with $L^p$ Constraints.

(reviews are hidden until publication/rejection)

reference=[4nn3]
title=The swapped inekoalaty game: a symmetric variant
author=fi8r
reviews:PENDING, ACCEPT, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]

reference=[8nk6]
title=Generalized Inekoalaty Game with Exponent p: Thresholds and Conjectures
author=slsx
reviews:PENDING, PENDING, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[generalized_game.tex,simulate_generalized.py]

reference=[araj]
title=Computer-verified recurrence analysis for the inekoalaty game
author=fi8r
reviews:PENDING, ACCEPT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[Inekoalaty.lean]

reference=[lunq]
title=Generalized Inekoalaty Game with $L^p$ Constraints
author=vnir
reviews:ACCEPT, ACCEPT, PENDING, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]

reference=[olab]
title=A Complete Solution to the Inekoalaty Game and Open Problems
author=3jl0
reviews:PENDING, ACCEPT, ACCEPT, ACCEPT
status=SUBMITTED
citations_count=0
attachments=[]

exit_code: 0
duration_ms: 240
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 297
stdout:
```

p=1, q=2:
  s=0.200, φ=1.600000, φ'≈0.857143
  s=0.500, φ=1.822876, φ'≈0.622036
  s=0.800, φ=1.966190, φ'≈0.314006
  s=1.000, φ=2.000000, φ'≈0.000000
  s=1.200, φ=1.948331, φ'≈-0.603567

p=1, q=3:
  s=0.200, φ=1.458239, φ'≈0.974734
  s=0.500, φ=1.733106, φ'≈0.835586
  s=0.800, φ=1.941653, φ'≈0.508966
  s=1.000, φ=2.000000, φ'≈0.000000
  s=1.200, φ=1.847922, φ'≈-2.430177

p=2, q=3:
  s=0.200, φ=1.623165, φ'≈0.336419
  s=0.500, φ=1.770550, φ'≈0.594520
  s=0.800, φ=1.943373, φ'≈0.478819
  s=1.000, φ=2.000000, φ'≈0.000000
  s=1.200, φ=1.859803, φ'≈-2.044977

p=3, q=4:
  s=0.200, φ=1.688784, φ'≈0.099814
  s=0.500, φ=1.767220, φ'≈0.432151
  s=0.800, φ=1.928217, φ'≈0.552225
  s=1.000, φ=2.000000, φ'≈-0.000000

```
stderr:
```
```

exit_code: 1
duration_ms: 322
stdout:
```

```
stderr:
```
Traceback (most recent call last):
  File "/home/agent/verify_claims.py", line 32, in 
    check_monotonic(p,q)
  File "/home/agent/verify_claims.py", line 23, in check_monotonic
    if val > prev + 1e-12:
       ^^^^^^^^^^^^^^^^^^
TypeError: '>' not supported between instances of 'complex' and 'float'
```

exit_code: 0
duration_ms: 229
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 331
stdout:
```
s=0.700, φ=1.890280
s=0.800, φ=1.943373
s=0.900, φ=1.983358
s=0.950, φ=1.995456
s=1.000, φ=2.000000
s=1.050, φ=1.994443
s=1.100, φ=1.974922
s=1.200, φ=1.859803

```
stderr:
```
```

exit_code: 0
duration_ms: 492
stdout:
```
p=1, q=2: max at s=1.000032, φ=2.000000
   predicted s=2^(1/q - 1/p) = 0.707107
   φ(0)=1.414214, φ(2^(1/q))=1.414214+0.000000j
p=1, q=3: max at s=1.000025, φ=2.000000
   predicted s=2^(1/q - 1/p) = 0.629961
   φ(0)=1.259921, φ(2^(1/q))=1.259921
p=2, q=3: max at s=1.000025, φ=2.000000
   predicted s=2^(1/q - 1/p) = 0.890899
   φ(0)=1.587401, φ(2^(1/q))=1.587401
p=3, q=4: max at s=1.000023, φ=2.000000
   predicted s=2^(1/q - 1/p) = 0.943874
   φ(0)=1.681793, φ(2^(1/q))=1.681793

```
stderr:
```
```

exit_code: 1
duration_ms: 356
stdout:
```

```
stderr:
```
Traceback (most recent call last):
  File "/home/agent/find_max.py", line 19, in 
    s_opt, val = find_max(p,q)
                 ^^^^^^^^^^^^^
  File "/home/agent/find_max.py", line 13, in find_max
    if val > best:
       ^^^^^^^^^^
TypeError: '>' not supported between instances of 'complex' and 'float'
```

exit_code: 0
duration_ms: 316
stdout:
```
p=1, q=2: phi not monotone at s=0.0014142135623730952, prev=1.4142135623730951, val=1.4156270688285102
p=1, q=3: phi not monotone at s=0.0012599210498948732, prev=1.2599210498948732, val=1.2611809705247945
p=2, q=3: phi not monotone at s=0.0012599210498948732, prev=1.5874010519681994, val=1.587402638310984
p=3, q=4: phi not monotone at s=0.001189207115002721, prev=1.681792830507429, val=1.6817928321879607
p=1, q=5: phi not monotone at s=0.001148698354997035, prev=1.148698354997035, val=1.149847053352032

```
stderr:
```
```

exit_code: 0
duration_ms: 407
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 3881
stdout:
```
p=1, q=2: predicted λ_c=0.707107, simulated λ_c=0.707141, predicted λ_upper=1.0, simulated λ_upper=1.000049
p=1, q=3: predicted λ_c=0.629961, simulated λ_c=0.629991, predicted λ_upper=1.0, simulated λ_upper=1.000049
p=2, q=3: predicted λ_c=0.793701, simulated λ_c=0.793739, predicted λ_upper=1.0, simulated λ_upper=1.000049
p=3, q=4: predicted λ_c=0.840896, simulated λ_c=0.840937, predicted λ_upper=1.0, simulated λ_upper=1.000049
p=2, q=5: predicted λ_c=0.659754, simulated λ_c=0.659786, predicted λ_upper=1.0, simulated λ_upper=1.000049
p=3, q=2: predicted λ_c=1.414214, simulated λ_c=1.131405, predicted λ_upper=1.0, simulated λ_upper=1.099951
p=5, q=2: predicted λ_c=2.828427, simulated λ_c=2.262776, predicted λ_upper=1.0, simulated λ_upper=1.099951

```
stderr:
```
```

exit_code: 0
duration_ms: 649
stdout:
```
p=2, q=3, λ=0.70: Bazza
p=2, q=3, λ=0.75: Bazza
p=2, q=3, λ=0.80: Draw
p=2, q=3, λ=0.85: Draw
p=2, q=3, λ=0.90: Draw
p=2, q=3, λ=0.95: Draw
p=2, q=3, λ=1.00: Draw
p=2, q=3, λ=1.05: Alice
p=2, q=3, λ=1.10: Alice

```
stderr:
```
```

exit_code: 0
duration_ms: 656
stdout:
```
λ=0.62500000: Bazza
λ=0.62750000: Bazza
λ=0.62875000: Bazza
λ=0.62937500: Bazza
λ=0.62968750: Bazza
λ=0.62984375: Bazza
λ=0.62992187: Bazza
λ=0.62996094: Draw
λ=0.62994141: Bazza
λ=0.62995117: Bazza
λ=0.62995605: Bazza
λ=0.62995850: Bazza
λ=0.62995972: Bazza
λ=0.62996033: Bazza
λ=0.62996063: Draw
λ=0.62996048: Bazza
λ=0.62996056: Draw
λ=0.62996052: Bazza
λ=0.62996054: Draw
λ=0.62996053: Draw
Threshold ~ 0.62996053

```
stderr:
```
```

exit_code: 0
duration_ms: 560
stdout:
```
λ=0.62: Bazza
λ=0.63: Draw
λ=0.64: Draw
λ=0.65: Draw
λ=0.66: Draw
λ=0.67: Draw
λ=0.68: Draw
λ=0.69: Draw
λ=0.70: Draw
λ=0.71: Draw
λ=0.72: Draw

```
stderr:
```
```

exit_code: 0
duration_ms: 778
stdout:
```
Threshold λ_c for p=1, q=3 ≈ 0.6300002670
λ=0.62999927: Draw
λ=0.63000027: Draw
λ=0.63000127: Draw

```
stderr:
```
```

exit_code: 0
duration_ms: 297
stdout:
```
Threshold λ_c for p=1, q=3 ≈ 0.629932
λ = 0.629921640625: Bazza
λ = 0.6299416406249999: Bazza

```
stderr:
```
```

exit_code: 0
duration_ms: 985
stdout:
```
λ=0.50: Alice cannot move at turn 3
λ=0.60: Alice cannot move at turn 3
λ=0.70: Draw at turn 200
λ=0.80: Draw at turn 200
λ=0.90: Draw at turn 200
λ=1.00: Draw at turn 200
λ=1.10: Bazza cannot move at turn 4
λ=1.20: Bazza cannot move at turn 4
λ=1.30: Bazza cannot move at turn 2
λ=1.40: Bazza cannot move at turn 2

```
stderr:
```
```

exit_code: 0
duration_ms: 225
stdout:
```
name = "Math"
version = "0.1.0"
defaultTargets = ["math"]

[[require]]
name = "mathlib"
git = "https://github.com/leanprover-community/mathlib4.git"
rev = "main"

[[lean_lib]]
name = "Math"

[[lean_exe]]
name = "math"
root = "Main"

```
stderr:
```
```

exit_code: 0
duration_ms: 344
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 902
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 331
stdout:
```
leanprover/lean4:v4.27.0-rc1

```
stderr:
```
```

exit_code: 2
duration_ms: 214
stdout:
```

```
stderr:
```
ls: cannot access '.lake/packages/': No such file or directory
```

exit_code: 0
duration_ms: 1398
stdout:
```
Lake version 5.0.0-src+2fcce72 (Lean version 4.27.0-rc1)

USAGE:
  lake [OPTIONS] 

COMMANDS:
  new       create a Lean package in a new directory
  init      create a Lean package in the current directory
  build ...    build targets
  query ...    build targets and output results
  exe  ...   build an exe and run it in Lake's environment
  check-build           check if any default build targets are configured
  test                  test the package using the configured test driver
  check-test            check if there is a properly configured test driver
  lint                  lint the package using the configured lint driver
  check-lint            check if there is a properly configured lint driver
  clean                 remove build outputs
  env  ...   execute a command in Lake's environment
  lean            elaborate a Lean file in Lake's context
  update                update dependencies and save them to the manifest

```
stderr:
```
```

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We determine the values of the parameter λ for which Alice or Bazza has a winning strategy in the two-player inekoalaty game. We prove that Alice wins if λ > 1, Bazza wins if λ < 1/√2, and the game ends in a draw (neither wins) for 1/√2 ≤ λ ≤ 1.

Review submitted for publication [zn8k].

Review submitted for publication [qxbb].

reference=[zn8k]
title=Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds
author=muk7
reviews:ACCEPT, ACCEPT, PENDING, PENDING
status=SUBMITTED
citations_count=0
attachments=[paper2.tex]
abstract = We solve the two-player inekoalaty game by introducing slack variables and proving that greedy strategies are optimal. The thresholds are λ = √2/2 and λ = 1: Bazza wins for λ < √2/2, the game is a draw for √2/2 ≤ λ ≤ 1, and Alice wins for λ > 1. The proof uses a monotonicity lemma and analysis of a one-dimensional recurrence. A similar result was independently obtained in [{rkrw}].

\documentclass{article}
\usepackage{amsmath,amsthm,amssymb}
\usepackage{enumitem}

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem{definition}{Definition}

\title{Slack Variable Approach to the Inekoalaty Game: Optimal Greedy Strategies and Thresholds}
\author{Researcher}
\date{}

\begin{document}

\maketitle

\begin{abstract}
We determine the values of the parameter $\lambda$ for which Alice (first player) has a winning strategy, Bazza (second player) has a winning strategy, or neither can force a win in the two-player inekoalaty game. The thresholds are $\lambda = \sqrt{2}/2$ and $\lambda = 1$: for $\lambda < \sqrt{2}/2$ Bazza wins, for $\sqrt{2}/2 \le \lambda \le 1$ the game is a draw, and for $\lambda > 1$ Alice wins. The proof uses a reformulation with slack variables, greedy strategies, and analysis of a one-dimensional recurrence. A similar result was independently obtained in [{rkrw}].
\end{abstract}

\section{Introduction}

The inekoalaty game is a two-player perfect-information game depending on a parameter $\lambda>0$. Players Alice and Bazza alternate turns, with Alice moving on odd turns and Bazza on even turns. On turn $n$ (starting at $n=1$) the player whose turn it is chooses a nonnegative real number $x_n$ satisfying a cumulative constraint:
\begin{itemize}
\item If $n$ is odd, Alice must ensure $x_1+x_2+\cdots+x_n\le \lambda n$.
\item If $n$ is even, Bazza must ensure $x_1^2+x_2^2+\cdots+x_n^2\le n$.
\end{itemize}
If a player cannot choose a suitable $x_n$, the game ends and the other player wins. If the game continues forever, neither player wins.

All chosen numbers are known to both players. The aim is to determine, for each $\lambda>0$, which player (if any) has a strategy that guarantees a win regardless of the opponent's moves.

\section{Notation and reformulation}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$. Define the \emph{slack variables}
\[
A_n=\lambda n-S_n,\qquad B_n=n-Q_n .
\]
The rules of the game are equivalent to the following:
\begin{itemize}
\item Initially $A_0=0$, $B_0=0$.
\item On turn $n$ (no matter the parity) the player chooses $x_n\ge0$ and updates
\begin{align}
A_n &= A_{n-1}+\lambda - x_n, \label{eq:Aupdate}\\
B_n &= B_{n-1}+1 - x_n^2. \label{eq:Bupdate}
\end{align}
\item If $n$ is odd, Alice must choose $x_n$ so that $A_n\ge0$.
\item If $n$ is even, Bazza must choose $x_n$ so that $B_n\ge0$.
\end{itemize}
The game ends when a player, on his or her turn, cannot pick $x_n$ that satisfies the corresponding nonnegativity condition. If the game never ends, it is a draw.

Observe that the constraints are only enforced on the moving player's slack; the other slack may become negative, but this will cause the opponent to lose on a later turn if it is not corrected.

\section{Greedy strategies}

For a player, a natural \emph{greedy} strategy is to choose the largest possible $x_n$ that does not violate the required slack condition, i.e.\ that makes the new slack exactly zero. Thus
\[
\text{Alice (odd $n$): } x_n = A_{n-1}+\lambda,\qquad
\text{Bazza (even $n$): } x_n = \sqrt{\,B_{n-1}+1\,}.
\]
These choices are always admissible when the corresponding slack condition can be satisfied at all.

The greedy strategy has the following monotonicity property, which will be crucial.

\begin{lemma}[Monotonicity]\label{lem:monotone}
Let $(A_{n-1},B_{n-1})$ be the state before a player's turn.
\begin{enumerate}
\item If Alice chooses any $x_n\le A_{n-1}+\lambda$ (so that $A_n\ge0$), then the resulting state $(A_n,B_n)$ satisfies $A_n\ge0$ and $B_n\ge B_n^{\mathrm{gr}}$, where $B_n^{\mathrm{gr}}$ is the value obtained by the greedy choice.
\item If Bazza chooses any $x_n\le\sqrt{B_{n-1}+1}$ (so that $B_n\ge0$), then the resulting state satisfies $B_n\ge0$ and $A_n\ge A_n^{\mathrm{gr}}$, where $A_n^{\mathrm{gr}}$ is the value obtained by the greedy choice.
\end{enumerate}
In other words, deviating from the greedy choice by taking a smaller $x_n$ can only increase the opponent's slack and therefore cannot improve the player's own prospects.
\end{lemma}
\begin{proof}
For Alice, $A_n = A_{n-1}+\lambda-x_n$. If $x_n$ is smaller than the greedy value, $A_n$ becomes larger, which is harmless for her. Moreover,
$B_n = B_{n-1}+1-x_n^2$; since $x_n\le A_{n-1}+\lambda = x_n^{\mathrm{gr}}$, we have $x_n^2\le (x_n^{\mathrm{gr}})^2$, hence $B_n\ge B_{n-1}+1-(x_n^{\mathrm{gr}})^2 = B_n^{\mathrm{gr}}$. The argument for Bazza is analogous.
\end{proof}

Consequently, if a player can guarantee a win (or a draw) by using the greedy strategy, then no deviation can prevent that outcome. This allows us to restrict attention to greedy play when searching for winning strategies.

\section{Analysis of the greedy dynamics}

Because the greedy strategy resets the relevant slack to zero, the state after each player's move can be described by a single variable. Let
\[
a_k = A_{2k},\qquad b_k = B_{2k-1}\qquad(k\ge0),
\]
i.e.\ $a_k$ is Alice's slack after Bazza's $2k$-th move (with $a_0=0$), and $b_k$ is Bazza's slack after Alice's $(2k-1)$-st move (with $b_0=0$). The greedy updates give
\begin{align}
b_k &= 1-(a_{k-1}+\lambda)^2, \label{eq:bupdate}\\
a_k &= \lambda-\sqrt{2-(a_{k-1}+\lambda)^2}, \label{eq:aupdate}
\end{align}
where we used that after Alice's greedy move $B_{2k-1}=b_k$ and after Bazza's greedy move $A_{2k}=a_k$.

Define $s_k = a_{k-1}+\lambda$ (so $s_1=\lambda$). Then (\ref{eq:aupdate}) becomes the recurrence
\begin{equation}\label{eq:srecurrence}
s_{k+1} = 2\lambda-\sqrt{2-s_k^{\,2}},\qquad k\ge1,
\end{equation}
with the condition $s_k^2\le2$ (otherwise the square‑root is not real, which means Bazza cannot move and loses).

\subsection{The function $f(s)=s+\sqrt{2-s^2}$}

The behaviour of (\ref{eq:srecurrence}) is governed by the function $f(s)=s+\sqrt{2-s^2}$ defined for $0\le s\le\sqrt2$. One checks that $f$ increases on $[0,1]$, attains its maximum $f(1)=2$, and decreases on $[1,\sqrt2]$, with $f(0)=f(\sqrt2)=\sqrt2$.

A fixed point of (\ref{eq:srecurrence}) satisfies $s=2\lambda-\sqrt{2-s^2}$, i.e.\ $f(s)=2\lambda$. Hence a fixed point exists iff $\sqrt2\le2\lambda\le2$, i.e.\
\[
\frac{\sqrt2}{2}\le\lambda\le1 .
\]

When a fixed point exists, the derivative of the map $g(s)=2\lambda-\sqrt{2-s^2}$ at the fixed point is $g'(s)=s/\sqrt{2-s^2}$. For the smaller fixed point (which lies in $[0,1]$) we have $g'(s)<1$, so it is attracting; for the larger fixed point (in $[1,\sqrt2]$) we have $g'(s)>1$, so it is repelling. Consequently, when $\frac{\sqrt2}{2}\le\lambda\le1$ the sequence $\{s_k\}$ converges to the attracting fixed point, and both slacks stay bounded away from $-\infty$; the game can continue forever.

If $\lambda< \frac{\sqrt2}{2}$ then $2\lambda<\sqrt2$, the equation $f(s)=2\lambda$ has no solution, and one can show that $s_k$ (hence $a_k$) decreases monotonically until $a_k+\lambda$ becomes negative, at which point Alice cannot move. Thus Bazza wins.

If $\lambda>1$ then $2\lambda>2$, the equation again has no solution, and $s_k$ increases monotonically until $s_k>\sqrt2$, which makes the square‑root in (\ref{eq:srecurrence}) undefined; this corresponds to $B_{n-1}+1<0$ for some even $n$, i.e.\ Bazza cannot move. Thus Alice wins.

The special case $\lambda=\sqrt2$ (which is $>1$) is covered by the last regime; indeed Alice can win already on the second move by taking $x_1=\lambda$.

\section{Main result}

\begin{theorem}\label{thm:main}
For the inekoalaty game with parameter $\lambda>0$:
\begin{enumerate}[label=(\roman*)]
\item If $\lambda<\dfrac{\sqrt2}{2}$, Bazza has a winning strategy (the greedy strategy).
\item If $\dfrac{\sqrt2}{2}\le\lambda\le1$, neither player has a winning strategy; both players can force at least a draw by using the greedy strategy.
\item If $\lambda>1$, Alice has a winning strategy (the greedy strategy).
\end{enumerate}
\end{theorem}

\begin{proof}
We treat the three ranges separately.

\noindent\textbf{Case $\lambda<\frac{\sqrt2}{2}$.}
Consider the greedy strategy for Bazza described in Section~3. Let $a_k$ be defined as above. From (\ref{eq:aupdate}) we have $a_k=\lambda-\sqrt{2-(a_{k-1}+\lambda)^2}$. Because $2\lambda<\sqrt2$, a simple induction shows that $a_k$ is strictly decreasing and satisfies $a_k+\lambda<0$ for some $k$. Indeed, the function $h(a)=\lambda-\sqrt{2-(a+\lambda)^2}$ satisfies $h(a)0$ (since $s_{k-1}^2<2$), so Bazza can always move. Hence the game never terminates. By Lemma~\ref{lem:monotone}, any deviation from greediness can only make the opponent's position better, therefore neither player can force a win.

\noindent\textbf{Case $\lambda>1$.}
Now the greedy strategy for Alice guarantees a win. From (\ref{eq:srecurrence}) we have $s_{k+1}=2\lambda-\sqrt{2-s_k^2}\ge2\lambda-\sqrt2$. Since $\lambda>1$, we obtain $s_{k+1}>2-\sqrt2>0$. Moreover, one proves by induction that $s_k$ is strictly increasing as long as $s_k\le\sqrt2$. Because $2\lambda-\sqrt{2-s^2}>s$ for all $s<\sqrt2$ when $\lambda>1$, the sequence increases until it eventually exceeds $\sqrt2$. When $s_k>\sqrt2$, the expression under the square‑root in (\ref{eq:aupdate}) becomes negative, which means $B_{2k-1}+1<0$; at the next even turn Bazza cannot choose any $x_{2k}$ with $B_{2k}\ge0$, so he loses. Hence Alice's greedy strategy wins.

For $\lambda>\sqrt2$ the win is even faster: Alice can choose $x_1=\lambda$, then $Q_1=\lambda^2>2$, so at $n=2$ Bazza already cannot move.
\end{proof}

\section{Remarks}

\begin{enumerate}
\item The thresholds $\lambda=\frac{\sqrt2}{2}$ and $\lambda=1$ are sharp: for $\lambda$ exactly equal to one of these values the corresponding player still cannot force a win; the game remains a draw (for $\lambda=\frac{\sqrt2}{2}$ and $\lambda=1$) or becomes a win for the other player (for $\lambda=\sqrt2$ which is $>1$).
\item The greedy strategies are not only winning or drawing, but they are also \emph{optimal} in the sense that any deviation cannot improve the outcome for the deviating player (Lemma~\ref{lem:monotone}).
\item The same analysis applies if the constraints are required to hold after every turn (not only on the moving player's turn), because the greedy strategies keep both slacks nonnegative at all times except possibly the slack of the player who has just moved, which is exactly zero.
\end{enumerate}

\section{Conclusion}

We have completely solved the inekoalaty game, determining the ranges of the parameter $\lambda$ for which Alice wins, Bazza wins, or the game is a draw. The solution relies on a reformulation in terms of slack variables, the identification of optimal greedy strategies, and a one‑dimensional recurrence whose fixed‑point behaviour gives the precise thresholds $\frac{\sqrt2}{2}$ and $1$.

\end{document}

(reviews are hidden until publication/rejection)

exit_code: 0
duration_ms: 522
stdout:
```
import Mathlib.Analysis.SpecialFunctions.Pow.Real

open Real

/- The inekoalaty game parameterized by λ > 0. -/
structure GameState where
  turn : ℕ          -- current turn number (starting at 1)
  sum : ℝ          -- S_n = sum of x_i up to previous turn (i.e., before choosing x_n)
  sqSum : ℝ        -- Q_n = sum of squares up to previous turn
  deriving DecidableEq

def initialState : GameState :=
  { turn := 1, sum := 0, sqSum := 0 }

def AliceTurn (λ : ℝ) (s : GameState) : Set ℝ :=
  { x | x ≥ 0 ∧ s.sum + x ≤ λ * s.turn }

def BazzaTurn (λ : ℝ) (s : GameState) : Set ℝ :=
  { x | x ≥ 0 ∧ s.sqSum + x ^ 2 ≤ s.turn }

def move (λ : ℝ) (s : GameState) (x : ℝ) : GameState :=
  { turn := s.turn + 1,
    sum := s.sum + x,
    sqSum := s.sqSum + x ^ 2 }

-- Winning condition: a player cannot move on their turn.
def AliceCannotMove (λ : ℝ) (s : GameState) : Prop :=
  s.turn % 2 = 1 ∧ AliceTurn λ s = ∅

def BazzaCannotMove (λ : ℝ) (s : GameState) : Prop :=
  s.turn % 2 = 0 ∧ BazzaTurn λ s = ∅

-- A play is a sequence of states and moves.
inductive Play (λ : ℝ) : GameState → Type where
  | start : Play λ initialState
  | step : (s : GameState) → (x : ℝ) → (h : if s.turn % 2 = 1 then x ∈ AliceTurn λ s else x ∈ BazzaTurn λ s) →
    Play λ (move λ s x) → Play λ s

-- A strategy for Alice is a function that given a state where it's her turn, returns a move.
def AliceStrategy (λ : ℝ) := ∀ (s : GameState), s.turn % 2 = 1 → ℝ

-- A strategy for Bazza similarly.
def BazzaStrategy (λ : ℝ) := ∀ (s : GameState), s.turn % 2 = 0 → ℝ

-- Outcome: who wins? We'll define later.

-- Basic lemma: if λ ≥ 1 and quadratic constraint holds, then linear constraint holds.
lemma linear_bound_from_quadratic (λ : ℝ) (hλ : λ ≥ 1) (n : ℕ) (S Q : ℝ) (hQ : Q ≤ n)
    (hSq : S ^ 2 ≤ n * Q) : S ≤ λ * n := by
  have : S ≤ n := by
    nlinarith? -- S^2 ≤ n * Q ≤ n * n = n^2, so S ≤ n (since S ≥ 0? Actually S could be negative? But x_i ≥ 0, so S ≥ 0.)
    -- Need S ≥ 0. We'll assume.
  nlinarith [hλ]

-- Cauchy-Schwarz inequality for sequences.
-- We'll use the version: (∑ x_i)^2 ≤ n ∑ x_i^2.
-- But we need to formalize for any finite sequence.
-- For now, we skip.

end Inekoalaty

```
stderr:
```
```

exit_code: 0
duration_ms: 378
stdout:
```
total 12
drwxr-xr-x 2 agent agent 4096 Jan 10 07:39 .
drwxr-xr-x 3 agent agent 4096 Jan 10 07:39 ..
-rw-r--r-- 1 agent agent 2314 Jan 10 07:39 Inekoalaty.lean

```
stderr:
```
```

Attachment downloaded to /home/agent/publications/qxbb.

reference=[qxbb]
title=The inekoalaty game: preliminary analysis and conjectures
author=slsx
reviews:REJECT, REJECT, REJECT, PENDING
status=SUBMITTED
citations_count=0
attachments=[Inekoalaty.lean]
abstract = We study the two-player inekoalaty game with parameter $\lambda>0$. We provide partial results: Alice wins for $\lambda>\sqrt{2}$, Bazza wins for $\lambda<\lambda_c$ (with $\lambda_c\approx0.7016$), and the game is a draw for $\lambda_c<\lambda<\sqrt{2}$. We conjecture the exact threshold $\lambda_c=\sqrt{32/65}$.

# The inekoalaty game

We analyze the game described in the goal.

## Definitions

Let $\lambda>0$ be a parameter. The game proceeds in turns $n=1,2,\dots$. Denote $x_n\ge0$ the number chosen at turn $n$. Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$. On odd $n$ (Alice's turn) we must have $S_n\le\lambda n$; on even $n$ (Bazza's turn) we must have $Q_n\le n$. If a player cannot choose a suitable $x_n$, the game ends and the other player wins. If the game continues forever, neither wins.

## Elementary bounds

By Cauchy–Schwarz, $S_n^2\le n Q_n$. Consequently, if $Q_n\le n$ then $S_n\le n$. Hence for $\lambda\ge1$ the linear constraint is automatically satisfied whenever the quadratic constraint holds. This suggests $\lambda=1$ may be a critical value.

## Alice's winning strategy for large $\lambda$

**Theorem 1.** If $\lambda>\sqrt2$, Alice has a winning strategy.

*Proof.* Alice simply chooses $x_n=\lambda$ on every one of her turns (when possible). We show that Bazza cannot move at turn $2$.

After turn~1 we have $S_1=\lambda$, $Q_1=\lambda^2$. At turn~2 Bazza must pick $x_2\ge0$ with $Q_2=\lambda^2+x_2^2\le2$. Since $\lambda^2>2$, the inequality cannot be satisfied for any $x_2$. Hence Bazza loses immediately. ∎

For $\lambda\in(1,\sqrt2]$ the same greedy strategy does not win instantly, but we conjecture that Alice can still force a win. Numerical simulations suggest that when $\lambda>1$ the greedy play eventually makes $Q_n$ exceed $n$ on Bazza's turn.

## Bazza's winning strategy for small $\lambda$

Consider the *greedy* strategy for Bazza: on his turns he chooses the largest possible $x_n$, i.e. $x_n=\sqrt{n-Q_{n-1}}$.

**Theorem 2.** If $\lambda<\sqrt{32/65}\approx0.7016$, then under greedy play by both players Alice loses at turn $5$.

*Proof.* Compute the moves explicitly.  
Turn~1: $x_1=\lambda$, $S_1=\lambda$, $Q_1=\lambda^2$.  
Turn~2: $x_2=\sqrt{2-\lambda^2}$, $S_2=\lambda+\sqrt{2-\lambda^2}$, $Q_2=2$.  
Turn~3: $x_3=3\lambda-S_2$, $S_3=3\lambda$, $Q_3=2+(3\lambda-S_2)^2$.  
Turn~4: $x_4=\sqrt{4-Q_3}$, $S_4=3\lambda+\sqrt{4-Q_3}$, $Q_4=4$.  
Turn~5: Alice can choose a non‑negative $x_5$ only if $S_4\le5\lambda$. A direct calculation shows that this inequality is equivalent to $7\lambda\ge4\sqrt{2-\lambda^2}$, i.e. $49\lambda^2\ge16(2-\lambda^2)$, i.e. $65\lambda^2\ge32$. Hence when $\lambda^2<32/65$ we have $S_4>5\lambda$ and Alice cannot move. ∎

Thus for $\lambda<\sqrt{32/65}$ Bazza has a winning strategy (the greedy one). Numerical experiments indicate that for $\lambda$ slightly above this value the greedy play continues indefinitely. However, Alice could deviate from the greedy choice on her first turn; by taking $x_1=0$ she can survive longer. A more refined analysis shows that for $\lambda\ge\frac{6\sqrt2}{13}\approx0.653$ Alice can avoid losing at least until turn~5. Hence the true threshold $\lambda_c$ lies between $0.653$ and $0.7016$.

## The draw region

Simulations suggest that for $\lambda\in(\sqrt{32/65},\sqrt2)$ both players can keep the game going forever by following the greedy strategy. In this regime the average sum $S_n/n$ tends to $\lambda$ and the average square sum $Q_n/n$ tends to $1$, with the quadratic constraint being tight on even turns and the linear constraint being tight on odd turns. Consequently neither player can force a win; the game is a draw.

## Conjectures

1. **Exact threshold.** There exists a critical $\lambda_c=\sqrt{32/65}$ such that  
   * Bazza has a winning strategy for $\lambda<\lambda_c$,  
   * Alice has a winning strategy for $\lambda>\sqrt2$,  
   * for $\lambda\in[\lambda_c,\sqrt2]$ the game is a draw (neither player can force a win).

2. **Optimal strategies.** For $\lambda<\lambda_c$ Bazza's greedy strategy is optimal. For $\lambda>\sqrt2$ Alice's greedy strategy is optimal. In the intermediate region both players should play greedily to avoid losing.

## Further questions

* Determine rigorously whether Alice can win for $\lambda\in(1,\sqrt2]$.  
* Find the exact value of $\lambda_c$ (we suspect it is $\sqrt{32/65}$).  
* Characterise the set of states from which a player can force a win.

## Lean formalisation

We have begun a formalisation of the game in Lean; the code is available as an attachment. It defines the game state, legal moves, and contains a lemma that for $\lambda\ge1$ the quadratic constraint implies the linear constraint.

\end{document}

(reviews are hidden until publication/rejection)

Successfully reported.

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, ACCEPT
status=PUBLISHED
citations_count=0
attachments=[]
abstract = We determine the values of the parameter λ for which Alice or Bazza has a winning strategy in the two-player inekoalaty game. We prove that Alice wins if λ > 1, Bazza wins if λ < 1/√2, and the game ends in a draw (neither wins) for 1/√2 ≤ λ ≤ 1.

We analyze the two-player inekoalaty game with parameter $\lambda > 0$.
The game proceeds in turns $n=1,2,\dots$.
On odd $n$, Alice chooses a nonnegative real number $x_n$ satisfying
\[
x_1+\dots+x_n\le \lambda n .
\]
On even $n$, Bazza chooses a nonnegative real number $x_n$ satisfying
\[
x_1^2+\dots+x_n^2\le n .
\]
If a player cannot choose a suitable $x_n$, the game ends and the other player wins.
If the game never ends, neither player wins.
All previous choices are known to both players.

\section*{Reduction to a one-dimensional recurrence}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$.
Denote by $a_k=x_{2k-1}$ (Alice's $k$-th move) and $b_k=x_{2k}$ (Bazza's $k$-th move).

\paragraph{Optimal moves.}
At her turn, Alice wishes to make $Q$ as large as possible (to threaten Bazza's future square‑sum constraint) while respecting her own linear constraint.
Given a remaining linear budget $B=\lambda(2k-1)-S_{2k-2}$, the choice $a_k=B$ maximizes $a_k^2$ and therefore maximizes the increase of $Q$.
Hence an optimal strategy for Alice is to use all her available budget each time:
\begin{equation}\label{eq:AliceOpt}
a_k = \lambda(2k-1)-S_{2k-2}\qquad (k\ge1).
\end{equation}

At his turn, Bazza wishes to make $S$ as large as possible (to threaten Alice's future linear constraint) while respecting his square‑sum constraint.
Given a remaining square budget $B'=2k-Q_{2k-1}$, the choice $b_k=\sqrt{B'}$ maximizes $b_k$ and therefore maximizes the increase of $S$.
Hence an optimal strategy for Bazza is to use all his square budget each time:
\begin{equation}\label{eq:BazzaOpt}
b_k = \sqrt{2k-Q_{2k-1}}\qquad (k\ge1).
\end{equation}

Consequently, if both players adopt these optimal strategies, the inequalities in the rules become equalities:
\begin{align}
S_{2k-1}&=\lambda(2k-1),\label{eq:Seq}\\
Q_{2k}&=2k.\label{eq:Qeq}
\end{align}

\paragraph{Recurrence for Alice's moves.}
From (\ref{eq:Seq}) we have $S_{2k-2}= \lambda(2k-3)+b_{k-1}$.
Substituting this into (\ref{eq:AliceOpt}) yields
\[
a_k = \lambda(2k-1)-\bigl(\lambda(2k-3)+b_{k-1}\bigr)=2\lambda-b_{k-1}.
\]
Using (\ref{eq:BazzaOpt}) for $b_{k-1}$ and (\ref{eq:Qeq}) we obtain $b_{k-1}=\sqrt{2-a_{k-1}^2}$.
Thus we obtain the recurrence
\begin{equation}\label{eq:rec}
a_{k+1}=2\lambda-\sqrt{2-a_k^2},\qquad a_1=\lambda .
\end{equation}
The game continues as long as $a_k\ge0$ (Alice can move) and $a_k^2\le2$ (Bazza can move).
If $a_k<0$ then Alice loses at turn $2k-1$; if $a_k^2>2$ then Bazza loses at turn $2k$.

Hence the game reduces to studying the dynamical system (\ref{eq:rec}) on the interval $[0,\sqrt2]$.

\section*{Analysis of the recurrence}

Define $f(x)=2\lambda-\sqrt{2-x^2}$ for $x\in[0,\sqrt2]$.
$f$ is strictly increasing and satisfies $f(x)\in\mathbb{R}$ precisely when $x^2\le2$.

\subsection*{Fixed points}
The fixed points of $f$ are the solutions of $x=2\lambda-\sqrt{2-x^2}$.
Setting $y=\sqrt{2-x^2}$ gives $y^2-2\lambda y+2\lambda^2-1=0$, whence
\[
y=\lambda\pm\sqrt{1-\lambda^2}.
\]
Thus real fixed points exist only when $\lambda\le1$; they are
\[
x_{\pm}= \lambda\pm\sqrt{1-\lambda^2}.
\]
Both $x_{\pm}$ lie in $[0,\sqrt2]$ exactly when $\lambda\ge1/\sqrt2$.
For $\lambda=1/\sqrt2$ we have $x_-=0$ and $x_+=\sqrt2$;
for $\lambda=1$ we have $x_-=x_+=1$.

The derivative of $f$ at a fixed point is
\[
f'(x_{\pm})=\frac{x_{\pm}}{2\lambda-x_{\pm}}.
\]
Since $2\lambda-x_+=x_-$ and $2\lambda-x_-=x_+$, we obtain
$f'(x_+)=x_+/x_->1$ (repelling) and $f'(x_-)=x_-/x_+<1$ (attracting).

\subsection*{Global behavior}

\begin{itemize}
\item \textbf{Case $\lambda>1$.} Then $f(x)-x=2\lambda-(\sqrt{2-x^2}+x)\ge2\lambda-2>0$ for all $x\in[0,\sqrt2]$,
because $\sqrt{2-x^2}+x\le2$ (maximum attained at $x=1$).
Hence $a_{k+1}>a_k$; the sequence $(a_k)$ is strictly increasing.
If it stayed bounded above by $\sqrt2$, it would converge to a fixed point, but no fixed point exists for $\lambda>1$.
Consequently $a_k$ must exceed $\sqrt2$ after finitely many steps, and Bazza loses.
Thus Alice wins for $\lambda>1$.

\item \textbf{Case $\lambda<1/\sqrt2$.} Here $2\lambda<\sqrt2$, so $f(0)=2\lambda-\sqrt2<0$.
Moreover, for $x\in[0,\lambda]$ we have $\sqrt{2-x^2}\ge\sqrt{2-\lambda^2}>\lambda$ (since $\lambda<1/\sqrt2$ implies $\lambda^2<1/2$ and $\sqrt{2-\lambda^2}>\sqrt{3/2}>\lambda$).
Hence $f(x)-x=2\lambda-(\sqrt{2-x^2}+x)<2\lambda-(\lambda+\lambda)=0$; therefore $f(x)x$ for $xx_+$.
Since $a_1=\lambda\in[x_-,x_+]$, the sequence $(a_k)$ is monotone and converges to the attracting fixed point $x_-$.
In particular $a_k\in[0,\sqrt2]$ for all $k$; therefore both players can always move and the game never ends.
Hence neither player has a winning strategy; the game is a draw.
\end{itemize}

\section*{Conclusion}

We have proved the following classification:

\begin{center}
\begin{tabular}{|c|c|}
\hline
$\lambda$ & Outcome \\ \hline
$\lambda>1$ & Alice wins \\ \hline
$\lambda<1/\sqrt2$ & Bazza wins \\ \hline
$1/\sqrt2\le\lambda\le1$ & draw (neither wins) \\ \hline
\end{tabular}
\end{center}

In particular, Alice has a winning strategy exactly for $\lambda>1$,
Bazza has a winning strategy exactly for $\lambda<1/\sqrt2$,
and for the intermediate values the game can continue forever.

\end{document}

reviewer=3jl0
grade=ACCEPT
**Review of "Optimal Strategies for the Inekoalaty Game"**

I have carefully verified the proof step by step. The paper reduces the game to a one-dimensional recurrence under the assumption that both players use greedy strategies (using all available budget at each turn). This reduction is correctly derived: letting $a_k=x_{2k-1}$ and $b_k=x_{2k}$, the greedy choices lead to
$$
a_k = 2\lambda - b_{k-1},\qquad b_{k-1}=\sqrt{2-a_{k-1}^2},
$$
hence $a_{k+1}=2\lambda-\sqrt{2-a_k^2}$ with $a_1=\lambda$.

The analysis of the dynamical system $f(x)=2\lambda-\sqrt{2-x^2}$ is rigorous. The fixed points are computed as $x_{\pm}= \lambda\pm\sqrt{1-\lambda^2}$, existing precisely when $\lambda\le1$. The derivative calculation shows $x_+$ is repelling and $x_-$ attracting.

The case distinction is correctly handled:

1. **$\lambda>1$.** $f(x)-x>0$ for all $x\in[0,\sqrt2]$; therefore $(a_k)$ is strictly increasing. If it stayed bounded by $\sqrt2$, it would converge to a fixed point, but none exists. Hence $a_k$ must exceed $\sqrt2$ after finitely many steps, at which point Bazza cannot move. Thus Alice wins.

2. **$\lambda<1/\sqrt2$.** For $x\in[0,\lambda]$ one has $f(x)-x<0$, and $f(0)<0$. Hence $(a_k)$ is strictly decreasing and eventually becomes negative, making Alice unable to move. Thus Bazza wins.

3. **$1/\sqrt2\le\lambda\le1$.** Here $x_-\le\lambda\le x_+$ and $f(x)1\).**  The function \(f(x)=2\lambda-\sqrt{2-x^{2}}\) satisfies \(f(x)-x\ge2\lambda-2>0\); hence the sequence \((a_k)\) is strictly increasing. If it stayed bounded by \(\sqrt2\) it would converge to a fixed point, but no fixed point exists for \(\lambda>1\). Consequently \(a_k\) must exceed \(\sqrt2\) after finitely many steps, which means Bazza cannot move and Alice wins.

2. **\(\lambda<1/\sqrt2\).**  Here \(f(0)=2\lambda-\sqrt2<0\) and for \(x\in[0,\lambda]\) one has \(\sqrt{2-x^{2}}>\lambda\); therefore \(f(x)-x<0\). Thus \((a_k)\) is strictly decreasing and eventually becomes negative, so Alice loses – i.e., Bazza wins.

3. **\(1/\sqrt2\le\lambda\le1\).**  The recurrence has two fixed points \(x_{\pm}=\lambda\pm\sqrt{1-\lambda^{2}}\) with \(0\le x_{-}\le\lambda\le x_{+}\le\sqrt2\). One checks that \(f(x)x\) outside that interval. Since \(a_1=\lambda\) lies between the two fixed points, the sequence \((a_k)\) is monotone and converges to the attracting fixed point \(x_{-}\). In particular all \(a_k\) stay in \([0,\sqrt2]\); therefore both players can always move and the game continues forever – a draw.

All steps are clearly explained and mathematically sound. The reduction to the recurrence is justified by the optimality of using the full budget, which is intuitively clear and formally argued. The analysis of the recurrence uses elementary calculus (derivatives, monotonicity, fixed‑point theory) and is correct.

**Minor remarks**

* The argument that the greedy strategies are optimal could be made more explicit: one could note that increasing \(a_k\) (resp. \(b_k\)) always harms the opponent while not hurting the player’s own future possibilities, because the constraints are monotone. A short lemma to that effect would strengthen the presentation.
* In the case \(\lambda<1/\sqrt2\) the inequality \(\sqrt{2-\lambda^{2}}>\lambda\) holds because \(\lambda^{2}<1/2\); this could be mentioned for completeness.

**Conclusion**

The publication gives a complete and correct classification of the parameter \(\lambda\):

- Alice wins iff \(\lambda>1\);
- Bazza wins iff \(\lambda<1/\sqrt2\);
- for \(1/\sqrt2\le\lambda\le1\) the game can continue forever (draw).

The solution is elegant and fully answers the original problem. Therefore I recommend **acceptance** (ACCEPT).

reviewer=muk7
grade=ACCEPT
The paper presents a complete solution to the inekoalaty game, correctly identifying the thresholds $\lambda_1 = 1/\sqrt{2}$ and $\lambda_2 = 1$ that separate the winning regions for Bazza, the drawing region, and the winning region for Alice. The reduction to a one‑dimensional recurrence via greedy (optimal) strategies is sound, and the analysis of the recurrence is mathematically rigorous.

**Strengths:**
- The recurrence $a_{k+1}=2\lambda-\sqrt{2-a_k^2}$ is derived correctly and captures the essence of the game under optimal play.
- The fixed‑point analysis clearly distinguishes the three regimes.
- The arguments for monotonicity and eventual violation of the constraints are correct and well‑explained.

**Weaknesses / suggestions for improvement:**
- The justification that the greedy strategies are indeed optimal could be made more explicit. A lemma showing that any deviation from greediness only weakens a player's own position (as in the “monotonicity” lemma of the present reviewer’s own work) would strengthen the proof.
- The paper does not discuss the special case $\lambda=\sqrt{2}$ (where Alice can win already on the second move), but this case is covered by the regime $\lambda>1$ anyway.
- The presentation could be enhanced by including a brief discussion of the slack‑variable reformulation, which makes the updates more transparent.

**Overall assessment:** The solution is correct, the reasoning is clear, and the result is non‑trivial. The paper meets the standards for acceptance.

**Verification log:**
1. Checked the derivation of the recurrence: starting from the greedy equalities $S_{2k-1}=\lambda(2k-1)$ and $Q_{2k}=2k$, the algebra leading to $a_{k+1}=2\lambda-\sqrt{2-a_k^2}$ is correct.
2. Verified the fixed‑point equation $x=2\lambda-\sqrt{2-x^2}$ reduces to $x^2-2\lambda x+2\lambda^2-1=0$, giving $x_{\pm}=\lambda\pm\sqrt{1-\lambda^2}$.
3. Confirmed that real fixed points exist only for $\lambda\le1$ and lie in $[0,\sqrt2]$ precisely when $\lambda\ge1/\sqrt2$.
4. Checked the derivative $f'(x)=x/(2\lambda-x)$ and the stability conclusions (attracting for $x_-$, repelling for $x_+$).
5. Verified the three cases:
   - For $\lambda>1$, $f(x)-x\ge2\lambda-2>0$, so $a_k$ increases and must exceed $\sqrt2$ in finite time → Alice wins.
   - For $\lambda<1/\sqrt2$, $f(0)<0$ and $f(x)2$ (Bazza loses).

The analysis of the recurrence is correct and clearly presented. The author identifies the fixed points and their stability, leading to the classification:
- For $\lambda>1$ the sequence $a_k$ increases and eventually exceeds $\sqrt2$, so Bazza loses → Alice wins.
- For $\lambda<1/\sqrt2$ the sequence decreases and becomes negative, so Alice loses → Bazza wins.
- For $1/\sqrt2\le\lambda\le1$ the sequence converges to an interior fixed point, hence both players can move indefinitely → draw.

The reduction to the recurrence rests on the assumption that greedy play is optimal for both players. While the author does not give a formal proof of this optimality, the reasoning is convincing: at her turn Alice wants to maximise the increase of $Q$ (to threaten Bazza’s quadratic constraint), and choosing the maximal possible $x_n$ does indeed maximise that increase; similarly Bazza wants to maximise the increase of $S$ and choosing the maximal $x_n$ achieves that. Because the constraints are linear in the turn number, there is no advantage in saving slack for later turns – using it immediately is always at least as good. Hence the greedy strategies form a subgame-perfect equilibrium.

I have verified the algebraic derivations and the dynamical analysis; they are mathematically sound. The conclusion matches numerical experiments and gives a clear, complete answer to the problem.

**Minor remarks**  
1. The paper would be strengthened by a short justification why the greedy strategies are optimal (e.g. by a simple induction).  
2. A Lean formalisation of the recurrence analysis would be a valuable addition, but its absence does not detract from the correctness of the result.

Overall, this is a solid contribution that fully solves the posed problem. I recommend acceptance.

Grade: ACCEPT.

exit_code: 0
duration_ms: 10414
stdout:
```
test_real.lean:1:7: error(lean.unknownIdentifier): Unknown identifier `Real.sqrt`

```
stderr:
```
```

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:ACCEPT, ACCEPT, ACCEPT, PENDING
status=SUBMITTED
citations_count=0
attachments=[]
abstract = We determine the values of the parameter λ for which Alice or Bazza has a winning strategy in the two-player inekoalaty game. We prove that Alice wins if λ > 1, Bazza wins if λ < 1/√2, and the game ends in a draw (neither wins) for 1/√2 ≤ λ ≤ 1.

We analyze the two-player inekoalaty game with parameter $\lambda > 0$.
The game proceeds in turns $n=1,2,\dots$.
On odd $n$, Alice chooses a nonnegative real number $x_n$ satisfying
\[
x_1+\dots+x_n\le \lambda n .
\]
On even $n$, Bazza chooses a nonnegative real number $x_n$ satisfying
\[
x_1^2+\dots+x_n^2\le n .
\]
If a player cannot choose a suitable $x_n$, the game ends and the other player wins.
If the game never ends, neither player wins.
All previous choices are known to both players.

\section*{Reduction to a one-dimensional recurrence}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$.
Denote by $a_k=x_{2k-1}$ (Alice's $k$-th move) and $b_k=x_{2k}$ (Bazza's $k$-th move).

\paragraph{Optimal moves.}
At her turn, Alice wishes to make $Q$ as large as possible (to threaten Bazza's future square‑sum constraint) while respecting her own linear constraint.
Given a remaining linear budget $B=\lambda(2k-1)-S_{2k-2}$, the choice $a_k=B$ maximizes $a_k^2$ and therefore maximizes the increase of $Q$.
Hence an optimal strategy for Alice is to use all her available budget each time:
\begin{equation}\label{eq:AliceOpt}
a_k = \lambda(2k-1)-S_{2k-2}\qquad (k\ge1).
\end{equation}

At his turn, Bazza wishes to make $S$ as large as possible (to threaten Alice's future linear constraint) while respecting his square‑sum constraint.
Given a remaining square budget $B'=2k-Q_{2k-1}$, the choice $b_k=\sqrt{B'}$ maximizes $b_k$ and therefore maximizes the increase of $S$.
Hence an optimal strategy for Bazza is to use all his square budget each time:
\begin{equation}\label{eq:BazzaOpt}
b_k = \sqrt{2k-Q_{2k-1}}\qquad (k\ge1).
\end{equation}

Consequently, if both players adopt these optimal strategies, the inequalities in the rules become equalities:
\begin{align}
S_{2k-1}&=\lambda(2k-1),\label{eq:Seq}\\
Q_{2k}&=2k.\label{eq:Qeq}
\end{align}

\paragraph{Recurrence for Alice's moves.}
From (\ref{eq:Seq}) we have $S_{2k-2}= \lambda(2k-3)+b_{k-1}$.
Substituting this into (\ref{eq:AliceOpt}) yields
\[
a_k = \lambda(2k-1)-\bigl(\lambda(2k-3)+b_{k-1}\bigr)=2\lambda-b_{k-1}.
\]
Using (\ref{eq:BazzaOpt}) for $b_{k-1}$ and (\ref{eq:Qeq}) we obtain $b_{k-1}=\sqrt{2-a_{k-1}^2}$.
Thus we obtain the recurrence
\begin{equation}\label{eq:rec}
a_{k+1}=2\lambda-\sqrt{2-a_k^2},\qquad a_1=\lambda .
\end{equation}
The game continues as long as $a_k\ge0$ (Alice can move) and $a_k^2\le2$ (Bazza can move).
If $a_k<0$ then Alice loses at turn $2k-1$; if $a_k^2>2$ then Bazza loses at turn $2k$.

Hence the game reduces to studying the dynamical system (\ref{eq:rec}) on the interval $[0,\sqrt2]$.

\section*{Analysis of the recurrence}

Define $f(x)=2\lambda-\sqrt{2-x^2}$ for $x\in[0,\sqrt2]$.
$f$ is strictly increasing and satisfies $f(x)\in\mathbb{R}$ precisely when $x^2\le2$.

\subsection*{Fixed points}
The fixed points of $f$ are the solutions of $x=2\lambda-\sqrt{2-x^2}$.
Setting $y=\sqrt{2-x^2}$ gives $y^2-2\lambda y+2\lambda^2-1=0$, whence
\[
y=\lambda\pm\sqrt{1-\lambda^2}.
\]
Thus real fixed points exist only when $\lambda\le1$; they are
\[
x_{\pm}= \lambda\pm\sqrt{1-\lambda^2}.
\]
Both $x_{\pm}$ lie in $[0,\sqrt2]$ exactly when $\lambda\ge1/\sqrt2$.
For $\lambda=1/\sqrt2$ we have $x_-=0$ and $x_+=\sqrt2$;
for $\lambda=1$ we have $x_-=x_+=1$.

The derivative of $f$ at a fixed point is
\[
f'(x_{\pm})=\frac{x_{\pm}}{2\lambda-x_{\pm}}.
\]
Since $2\lambda-x_+=x_-$ and $2\lambda-x_-=x_+$, we obtain
$f'(x_+)=x_+/x_->1$ (repelling) and $f'(x_-)=x_-/x_+<1$ (attracting).

\subsection*{Global behavior}

\begin{itemize}
\item \textbf{Case $\lambda>1$.} Then $f(x)-x=2\lambda-(\sqrt{2-x^2}+x)\ge2\lambda-2>0$ for all $x\in[0,\sqrt2]$,
because $\sqrt{2-x^2}+x\le2$ (maximum attained at $x=1$).
Hence $a_{k+1}>a_k$; the sequence $(a_k)$ is strictly increasing.
If it stayed bounded above by $\sqrt2$, it would converge to a fixed point, but no fixed point exists for $\lambda>1$.
Consequently $a_k$ must exceed $\sqrt2$ after finitely many steps, and Bazza loses.
Thus Alice wins for $\lambda>1$.

\item \textbf{Case $\lambda<1/\sqrt2$.} Here $2\lambda<\sqrt2$, so $f(0)=2\lambda-\sqrt2<0$.
Moreover, for $x\in[0,\lambda]$ we have $\sqrt{2-x^2}\ge\sqrt{2-\lambda^2}>\lambda$ (since $\lambda<1/\sqrt2$ implies $\lambda^2<1/2$ and $\sqrt{2-\lambda^2}>\sqrt{3/2}>\lambda$).
Hence $f(x)-x=2\lambda-(\sqrt{2-x^2}+x)<2\lambda-(\lambda+\lambda)=0$; therefore $f(x)x$ for $xx_+$.
Since $a_1=\lambda\in[x_-,x_+]$, the sequence $(a_k)$ is monotone and converges to the attracting fixed point $x_-$.
In particular $a_k\in[0,\sqrt2]$ for all $k$; therefore both players can always move and the game never ends.
Hence neither player has a winning strategy; the game is a draw.
\end{itemize}

\section*{Conclusion}

We have proved the following classification:

\begin{center}
\begin{tabular}{|c|c|}
\hline
$\lambda$ & Outcome \\ \hline
$\lambda>1$ & Alice wins \\ \hline
$\lambda<1/\sqrt2$ & Bazza wins \\ \hline
$1/\sqrt2\le\lambda\le1$ & draw (neither wins) \\ \hline
\end{tabular}
\end{center}

In particular, Alice has a winning strategy exactly for $\lambda>1$,
Bazza has a winning strategy exactly for $\lambda<1/\sqrt2$,
and for the intermediate values the game can continue forever.

\end{document}

(reviews are hidden until publication/rejection)

exit_code: 0
duration_ms: 326
stdout:
```
λ=0.10000: Bazza
λ=0.50000: Bazza
λ=0.60000: Bazza
λ=0.70710: Bazza
λ=0.70711: Bazza
λ=0.71000: Draw
λ=0.80000: Draw
λ=0.90000: Draw
λ=1.00000: Draw
λ=1.00010: Alice
λ=1.10000: Alice
λ=1.20000: Alice
λ=1.41400: Alice
λ=1.50000: Alice

```
stderr:
```
```

exit_code: 0
duration_ms: 446
stdout:
```
Random test done

```
stderr:
```
```

System prompt updated

reference=[rkrw]
title=Optimal Strategies for the Inekoalaty Game
author=8wf0
reviews:PENDING, ACCEPT, ACCEPT, PENDING
status=SUBMITTED
citations_count=0
attachments=[]

exit_code: 0
duration_ms: 307
stdout:
```
lambda = 0.7071067811865475
k=1, a=0.70710678118654746172
k=2, a=0.18946869098150598276
k=3, a=0.01274946538817589570
k=4, a=0.00005747087105856252
k=5, a=0.00000000116775167314
k=6, a=-0.00000000000000022204
break

```
stderr:
```
```

exit_code: 0
duration_ms: 313
stdout:
```
lambda=0.8
a_1 = 0.800000
a_2 = 0.433810
a_3 = 0.253965
a_4 = 0.208777
a_5 = 0.201282
a_6 = 0.200184
a_7 = 0.200026
a_8 = 0.200004
a_9 = 0.200001
a_10 = 0.200000

lambda=0.9
a_1 = 0.900000
a_2 = 0.709129
a_3 = 0.576425
a_4 = 0.508592
a_5 = 0.480404
a_6 = 0.469883
a_7 = 0.466130
a_8 = 0.464813
a_9 = 0.464355
a_10 = 0.464195

lambda=1.0
a_1 = 1.000000
a_2 = 1.000000
a_3 = 1.000000
a_4 = 1.000000
a_5 = 1.000000
a_6 = 1.000000
a_7 = 1.000000
a_8 = 1.000000
a_9 = 1.000000
a_10 = 1.000000

lambda=1.1
a_1 = 1.100000
a_2 = 1.311181
a_3 = 1.670089

```
stderr:
```
```

exit_code: 0
duration_ms: 435
stdout:
```
error: unknown command 'add'

```
stderr:
```
```

exit_code: 1
duration_ms: 511
stdout:
```
test_sqrt.lean:1:0: error: object file '/home/agent/.elan/toolchains/leanprover--lean4---v4.27.0-rc1/lib/lean/Std/Data/Real.olean' of module Std.Data.Real does not exist

```
stderr:
```
```

exit_code: 0
duration_ms: 276
stdout:
```
{"version": "1.1.0",
 "packagesDir": ".lake/packages",
 "packages": [],
 "name": "Math",
 "lakeDir": ".lake"}

```
stderr:
```
```

exit_code: 0
duration_ms: 283
stdout:
```

```
stderr:
```
```

exit_code: 1
duration_ms: 547
stdout:
```
test_ineq.lean:1:0: error: unknown module prefix 'Mathlib'

No directory 'Mathlib' or file 'Mathlib.olean' in the search path entries:
/home/agent/Math/.lake/build/lib/lean
/home/agent/.elan/toolchains/leanprover--lean4---v4.27.0-rc1/lib/lean
/home/agent/.elan/toolchains/leanprover--lean4---v4.27.0-rc1/lib/lean

```
stderr:
```
```

(0 found)

exit_code: 0
duration_ms: 224
stdout:
```
.lake/build/lib/lean/Main.olean
.lake/build/lib/lean/Math/Basic.olean
.lake/build/lib/lean/Math.olean

```
stderr:
```
```

exit_code: 0
duration_ms: 315
stdout:
```
name = "Math"
version = "0.1.0"
defaultTargets = ["math"]

[[lean_lib]]
name = "Math"

[[lean_exe]]
name = "math"
root = "Main"

```
stderr:
```
```

exit_code: 0
duration_ms: 394
stdout:
```
total 64
drwxr-xr-x 1 agent agent 4096 Jan 10 07:33 .
drwxr-x--- 1 agent agent 4096 Jan 10 07:30 ..
drwxr-xr-x 7 agent agent 4096 Jan 10 07:10 .git
drwxr-xr-x 3 agent agent 4096 Jan 10 07:10 .github
-rw-r--r-- 1 agent agent    7 Jan 10 07:10 .gitignore
drwxr-xr-x 3 agent agent 4096 Jan 10 07:10 .lake
-rw-r--r-- 1 agent agent   68 Jan 10 07:10 Main.lean
drwxr-xr-x 1 agent agent 4096 Jan 10 07:32 Math
-rw-r--r-- 1 agent agent  143 Jan 10 07:10 Math.lean
-rw-r--r-- 1 agent agent    6 Jan 10 07:10 README.md
-rw-r--r-- 1 agent agent  110 Jan 10 07:10 lake-manifest.json
-rw-r--r-- 1 agent agent  128 Jan 10 07:10 lakefile.toml
-rw-r--r-- 1 agent agent   29 Jan 10 07:10 lean-toolchain
-rw-r--r-- 1 agent agent 1053 Jan 10 07:33 test.lean

```
stderr:
```
```

exit_code: 0
duration_ms: 1217
stdout:
```

```
stderr:
```
```

exit_code: 2
duration_ms: 554
stdout:
```

```
stderr:
```
grep: lakefile.lean: No such file or directory
```

exit_code: 0
duration_ms: 195
stdout:
```
-- This module serves as the root of the `Math` library.
-- Import modules here that should be built as part of the library.
import Math.Basic

```
stderr:
```
```

exit_code: 0
duration_ms: 1310
stdout:
```
test.lean:1:0: error: unknown module prefix 'Mathlib'

No directory 'Mathlib' or file 'Mathlib.olean' in the search path entries:
/home/agent/Math/.lake/build/lib/lean
/home/agent/.elan/toolchains/leanprover--lean4---v4.27.0-rc1/lib/lean
/home/agent/.elan/toolchains/leanprover--lean4---v4.27.0-rc1/lib/lean

```
stderr:
```
```

exit_code: 0
duration_ms: 524
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 288
stdout:
```

```
stderr:
```
```

(0 found)

Publication submitted.

exit_code: 0
duration_ms: 242
stdout:
```

```
stderr:
```
```

exit_code: 0
duration_ms: 185
stdout:
```
./Main.lean
./Math.lean
./Math/Basic.lean

```
stderr:
```
```

exit_code: 0
duration_ms: 406
stdout:
```
Build completed successfully (8 jobs).

```
stderr:
```
```

exit_code: 0
duration_ms: 329
stdout:
```
\documentclass{article}
\usepackage{amsmath,amssymb}
\usepackage{enumitem}

\title{Optimal Strategies for the Inekoalaty Game}
\author{Researcher}
\date{}

\begin{document}
\maketitle

\begin{abstract}
We analyze the two-player inekoalaty game with parameter $\lambda > 0$.
We determine the values of $\lambda$ for which Alice (the first player) has a winning strategy,
the values for which Bazza (the second player) has a winning strategy,
and the values for which the game can continue forever (a draw).
\end{abstract}

\section{Game Definition}
The game proceeds in turns $n=1,2,\dots$.
On odd $n$, Alice chooses a nonnegative real number $x_n$ satisfying
\[
x_1+\dots+x_n\le \lambda n .
\]
On even $n$, Bazza chooses a nonnegative real number $x_n$ satisfying
\[
x_1^2+\dots+x_n^2\le n .
\]
If a player cannot choose a suitable $x_n$, the game ends and the other player wins.
If the game never ends, neither player wins.
All previous choices are known to both players.

\section{Reduction to a One-Dimensional Recurrence}

Let $S_n=\sum_{i=1}^n x_i$ and $Q_n=\sum_{i=1}^n x_i^2$.
Denote by $a_k=x_{2k-1}$ (Alice's $k$-th move) and $b_k=x_{2k}$ (Bazza's $k$-th move).

\subsection{Optimal Moves}
At her turn, Alice wishes to make $Q$ as large as possible (to threaten Bazza's future square‑sum constraint) while respecting her own linear constraint.
Given a remaining linear budget $B=\lambda(2k-1)-S_{2k-2}$, the choice $a_k=B$ maximizes $a_k^2$ and therefore maximizes the increase of $Q$.
Hence an optimal strategy for Alice is to use all her available budget each time:
\begin{equation}\label{eq:AliceOpt}
a_k = \lambda(2k-1)-S_{2k-2}\qquad (k\ge1).
\end{equation}

At his turn, Bazza wishes to make $S$ as large as possible (to threaten Alice's future linear constraint) while respecting his square‑sum constraint.
Given a remaining square budget $B'=2k-Q_{2k-1}$, the choice $b_k=\sqrt{B'}$ maximizes $b_k$ and therefore maximizes the increase of $S$.
Hence an optimal strategy for Bazza is to use all his square budget each time:
\begin{equation}\label{eq:BazzaOpt}
b_k = \sqrt{2k-Q_{2k-1}}\qquad (k\ge1).

```
stderr:
```
```

exit_code: 0
duration_ms: 384
stdout:
```
lambda = 0.7071067811865475
k=1, A=0.707106781186547461715008466853760182857513427734375
k=2, A=0.1894686909815058381396906678546552793553165398653
k=3, A=0.0127494653881758523005549566324088138763688863556
k=4, A=0.0000574708710586087160930177234549065357493448144
k=5, A=1.1677517296085976080582501126663629984863E-9
k=6, A=-1.248895507946761889691470056801319E-16
Outcome: Bazza at iteration 6

```
stderr:
```
```

exit_code: 0
duration_ms: 409
stdout:
```
lambda=0.7071067812: Bazza at iteration 6
lambda=1.0: Draw at iteration 100000

```
stderr:
```
```

exit_code: 0
duration_ms: 449
stdout:
```
0.99900: Draw
0.99950: Draw
0.99990: Draw
1.00000: Draw
1.00010: Alice
1.00050: Alice

```
stderr:
```
```

exit_code: 0
duration_ms: 400
stdout:
```
1.000: Draw
1.001: Alice
1.002: Alice
1.003: Alice
1.004: Alice
1.005: Alice
1.006: Alice
1.007: Alice
1.008: Alice
1.009: Alice
1.010: Alice

```
stderr:
```
```

exit_code: 0
duration_ms: 276
stdout:
```
1.000: Draw
1.010: Alice
1.020: Alice
1.030: Alice
1.040: Alice
1.050: Alice
1.060: Alice
1.070: Alice
1.080: Alice
1.090: Alice
1.100: Alice

```
stderr:
```
```

exit_code: 0
duration_ms: 320
stdout:
```
lambda = 0.7071067812: Bazza
lambda - eps: Bazza
lambda + eps: Draw

```
stderr:
```
```

exit_code: 0
duration_ms: 198
stdout:
```
0.70700: Bazza
0.70710: Bazza
0.70720: Draw
0.70730: Draw
0.70740: Draw
0.70750: Draw
0.70760: Draw
0.70770: Draw
0.70780: Draw
0.70790: Draw

```
stderr:
```
```

exit_code: 0
duration_ms: 214
stdout:
```
0.705: Bazza
0.706: Bazza
0.707: Bazza
0.708: Draw
0.709: Draw
0.710: Draw

```
stderr:
```
```

exit_code: 0
duration_ms: 218
stdout:
```
0.650: Bazza
0.700: Bazza
0.710: Draw
0.720: Draw
0.730: Draw
0.740: Draw
0.750: Draw
0.760: Draw
0.770: Draw
0.780: Draw
0.790: Draw
0.800: Draw

```
stderr:
```
```

exit_code: 0
duration_ms: 294
stdout:
```
lambda=0.100: Bazza wins (A negative) (iter 2)
lambda=0.200: Bazza wins (A negative) (iter 2)
lambda=0.300: Bazza wins (A negative) (iter 2)
lambda=0.400: Bazza wins (A negative) (iter 2)
lambda=0.500: Bazza wins (A negative) (iter 2)
lambda=0.600: Bazza wins (A negative) (iter 2)
lambda=0.700: Bazza wins (A negative) (iter 3)
lambda=0.800: Draw (max iterations) (iter 1000)
lambda=0.900: Draw (max iterations) (iter 1000)
lambda=1.000: Draw (max iterations) (iter 1000)
lambda=1.100: Alice wins (A > sqrt(2)) (iter 3)
lambda=1.200: Alice wins (A > sqrt(2)) (iter 2)
lambda=1.300: Alice wins (A > sqrt(2)) (iter 2)
lambda=1.400: Alice wins (A > sqrt(2)) (iter 2)

```
stderr:
```
```

exit_code: 0
duration_ms: 124
stdout:
```
Python 3.12.3

```
stderr:
```
```