📈 economics

Ironing Without Concavification

This paper proposes a new geometric approach to solving standard screening problems with binding monotonicity constraints, demonstrating that when virtual values are quasi-concave, the optimal allocation is found by truncating the relaxed solution, and providing a specific algorithm for the concave case.

Original authors: Filip Tokarski

Published 2026-01-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Filip Tokarski

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a manager trying to assign tasks to a team of employees. Each employee has a different skill level (their "type"), ranging from a beginner to an expert. You want to give them tasks that maximize your company's profit.

In a perfect world, you would give the easiest task to the beginner and the hardest, most complex task to the expert. However, there's a catch: if you give the expert a task that is too easy, they might pretend to be a beginner to get an easier job. To stop this, you must ensure that as an employee's skill level goes up, the difficulty of their task also goes up (or stays the same). This is the monotonicity constraint.

The Problem: The "Bumpy" Road

The author, Filip Tokarski, tackles a classic economic puzzle: How do you design these tasks when the "perfect" plan (ignoring the rule that tasks must get harder as skills get higher) creates a bumpy, non-monotonic path?

Usually, economists solve this using a method called "Ironing." Imagine you have a crumpled piece of paper (the perfect plan). To make it flat and usable, you have to iron out the wrinkles. Traditional ironing is complex; it involves reshaping the entire curve at once, often requiring heavy math and smooth, continuous curves.

The New Approach: "Truncating" Instead of Ironing

Tokarski proposes a simpler, more intuitive way to fix the bumpy road. Instead of trying to smooth out the whole curve at once, he suggests a strategy he calls "Truncating."

Think of the "perfect plan" (the relaxed solution) as a rollercoaster track. Sometimes, the track dips down when it should be going up. Tokarski's method says:

Identify the dips: Find the exact spots where the track stops going up and starts going down (or vice versa). These are the "critical points."
Cut and Cap: Instead of reshaping the whole track, you simply "cut" the track at these points.
- If the track dips, you replace that section with a flat, horizontal line (a "cap").
- If the track jumps up too high, you clip it so it doesn't exceed a certain height.
The Result: You end up with a path that is always going up (or staying flat), satisfying the rule that higher-skilled employees get harder tasks, without needing complex reshaping.

The "Lego" Algorithm

The paper provides a step-by-step recipe (an algorithm) to do this, assuming the tasks are chosen from a specific range (like a ladder with rungs from 1 to 10).

Imagine you are building a staircase, but you only have a few specific blocks to work with.

Start at the bottom: You look at the first section of the perfect plan.
Find the first "turn": You locate the first point where the plan changes direction.
Optimize the cut: You ask, "If I flatten this section at a specific height, what height gives me the most profit?" You pick that height.
Move up: You lock that height in, move to the next section of the track, and repeat the process.

By doing this one section at a time, you build a staircase that is perfectly flat where it needs to be and climbs where it needs to climb. This is much easier than trying to reshape the whole mountain at once.

Why This Matters

The paper claims this method is powerful because it is robust.

No Smoothness Required: Traditional methods often assume the data is smooth and continuous (like a flowing river). Tokarski's method works even if the data is "chunky" or discrete (like stepping stones).
No Fancy Math Needed: It doesn't require the complex calculus usually needed for "ironing." It relies on simple logic: if the perfect plan goes the wrong way, just cap it at the right level.
General Applicability: It works whether you are selling insurance, setting prices, or assigning tasks, as long as the goal is to maximize value while keeping things fair and monotonic.

The Bottom Line

Tokarski's paper says: "Don't try to iron out every wrinkle in your plan. Just find the spots where the plan breaks the rules, cut them off, and cap them at the best possible level. It's a simpler, more direct way to find the perfect solution."

It turns a complex, global optimization problem into a series of simple, local decisions, making it easier to solve real-world screening problems where the rules are strict.

Technical Summary: "Ironing Without Concavification"

Problem Statement
The paper addresses the standard single-agent screening problem where a planner seeks to design an optimal allocation rule $x: [0,1] \to X$ for agents with types $\theta \in [0,1]$ . The planner maximizes the objective functional $F[x] = \int_0^1 J(x(\theta), \theta)d\theta$ , where $J$ represents the "virtual value." The allocation must satisfy incentive compatibility, which, under quasi-linear payoffs and the single-crossing property, requires the allocation rule $x(\theta)$ to be non-decreasing in $\theta$ .

The standard approach involves maximizing virtual values pointwise (the "relaxed problem") and then correcting the solution to satisfy monotonicity. When virtual values are not concave, the standard "ironing" procedure (Myerson, 1981; Toikka, 2011) or optimal control methods (Guesnerie and Laffont, 1984) are typically employed to transform virtual values or solve the constrained optimization.

Methodology and Core Approach
The author proposes an alternative methodology that avoids transforming virtual values. Instead, the approach involves:

Solving the relaxed problem (ignoring the monotonicity constraint) to obtain a pointwise optimal allocation $x_R$ .
Identifying "critical points" $I = \{i_1, \dots, i_{|I|}\}$ where $x_R$ changes monotonicity (i.e., switches from increasing to decreasing or vice versa).
Constructing the optimal monotonic solution by "truncating" $x_R$ within the intervals defined by these critical points.

The paper establishes that the optimal solution $x^*$ can be parameterized by a vector $v$ of allocation values at the critical points. Specifically, on intervals where $x_R$ is increasing, the optimal solution is a truncation of $x_R$ between adjacent values in $v$ ; on intervals where $x_R$ is decreasing, the solution is constant.

Key Results

Theorem 1 (Structure of the Solution): The paper proves that if an optimal allocation rule exists, it takes the form of a specific truncation of the relaxed solution $x_R$ . The optimal truncation is determined by the allocations at the critical points where $x_R$ changes monotonicity. This result holds under weak assumptions:
- Virtual values $J(\cdot, \theta)$ are weakly quasi-concave.
- $J$ is uniformly bounded.
- The relaxed solution $x_R$ is piecewise monotonic.
- Crucially, the result does not require $J$ to be concave, does not require continuity or differentiability, and applies even when the allocation set $X$ is discrete.
Algorithm 1 (Solution Procedure): Under the additional assumption that $X$ is a compact interval $[l, h]$ and $J(\cdot, \theta)$ is continuous and weakly concave, the author provides an iterative algorithm.
- The algorithm starts with $x_R$ and iteratively processes intervals between critical points.
- In each step $n$ , it optimizes a truncation parameter $\tilde{v}$ to maximize the objective over the interval up to the $(n+1)$ -th critical point, effectively "ironing out" the non-monotonicity of the previous partial solution.
- Theorem 2 confirms that under Assumption 3, this algorithm converges to the global optimum of the planner's problem.

Significance and Claims
The paper claims that this approach offers a more direct geometric interpretation of the ironing process. By framing the solution as an optimal truncation of the relaxed problem, the method:

Generalizes existing insights: It recovers the structure of solutions found in literature without relying on continuity, differentiability, or concavity of virtual values.
Extends applicability: Unlike previous methods that often assume continuous allocation spaces, this approach is valid for discrete allocation sets.
Simplifies computation: The proposed algorithm provides a constructive method to find the optimal rule by solving a sequence of one-dimensional optimization problems (finding the optimal truncation level) rather than solving a complex global constrained optimization or transforming the virtual value function.

The author explicitly contrasts this with prior work by noting that while previous approaches often require transforming virtual values to ensure pointwise maximization yields an increasing solution, this method transforms the allocation directly after solving the relaxed problem, relying on the geometric properties of quasi-concavity and monotonicity changes.