PORF Encoding in Mechanism Design

• PORF encoding is a mechanism design approach that computes coalition-dependent price functions based solely on agents’ reports to ensure strategy-proofness and individual rationality.
• It decouples the neural network’s learning of price functions from combinatorial exclusion logic by using a deterministic subroutine for coalition formation.
• The integration of analytical priors with gradient-based training and supervised initialization yields a computationally efficient method with robust feasibility and monotonicity guarantees.

A price-oriented rationing-free (PORF) mechanism is a class of mechanisms in mechanism design for public project problems where, for each agent $i$ and each reported profile of the others $v_{-i}$, the mechanism computes a finite menu of outcome/price pairs $(x_i^k, p_i^k)$ from which the agent selects the utility-maximizing option. In single-dimensional, single-unit settings, this reduces to a threshold allocation and payment rule based on a "price" $c_i(v_{-i})$ determined by others' reports, guaranteeing strategy-proofness and individual rationality. Neural network-based implementations of PORF mechanisms for excludable public projects restructure the learning task into learning these price functions, while delegating the iterative logic of agent exclusions to a separate deterministic subroutine. This encoding enables the end-to-end optimization of nearly optimal, feasible, and robust mechanisms with continuous analytical priors and deep-learning-based function approximation (Wang et al., 2020).

1. Formal Definition and Structure of PORF Mechanisms

A mechanism is PORF if, for every agent $i$ and every report profile $v_{-i}$ by other agents, it:

• (i) Computes offline a menu $\{(x_i^k, p_i^k)\}_{k \in K(v_{-i})}$ of outcome/price pairs as a deterministic function of $v_{-i}$.
• (ii) Lets agent $i$ choose the option maximizing quasi-linear utility $v_i - p$.

In the canonical single-dimensional, single-unit case, this is realized via a threshold:

• Allocation: $x_i(v_i, v_{-i}) = 1$ iff $v_i \geq c_i(v_{-i})$.
• Payment: $$p_i(v_i, v_{-i}) = c_i(v_{-i}) \cdot x_i(v_i, v_{-i})$$.

Here, $c_i(\cdot)$ (the "price") depends only on $v_{-i}$. Strategy-proofness arises because agents optimize $v_i - c_i(v_{-i})$ by truthful reporting.

For excludable public projects (where agents can be excluded from the provision of the public good), $c_i(v_{-i})$ is determined by finding the largest coalition $S^*(v_{-i})$ collectively willing to pay, assigning each member a cost share from the coalition's cost vector. The iterative coalition-finding process is implemented as a deterministic, off-network subroutine, insulating the neural network from the combinatorial exclusion logic (Wang et al., 2020).

2. Neural Network Encoding of PORF Mechanisms

Implementation of PORF mechanisms for public projects leverages the decoupling of price computation and coalition logic:

• The neural network's task is to learn price functions $c_i(\cdot)$ for each coalition mask $b \in \{0,1\}^n$, where $b_j = 1$ if agent $j$ is present.
• Network architecture: Each input $b$ is encoded as a one-hot mask to a four-layer fully-connected ReLU MLP (width 100), outputting raw logits $\in \mathbb{R}^n$.
• Post-processing:
  • Constraint (i): Nonnegativity $OUT(b)_j \geq 0$.
  • Constraint (ii): Cost shares sum to $1$ among remaining agents: $\sum_{j: b_j = 1} OUT(b)_j = 1$.
  • Constraint (iii): Monotonicity under exclusion: if $b \to b'$ by flipping one $1 \to 0$, then $OUT(b)_j \leq OUT(b')_j$ for all $j$.

Constraint satisfaction and feasibility are enforced by setting logits for absent agents to large negative values before softmax, and by adding monotonicity penalties during training via $\mathrm{ReLU}$ loss terms for every admissible pair $(b, b')$.

The iterative exclusion logic—identifying "objectors" and recomputing coalitions—is entirely managed off-network in a deterministic subroutine, reducing the neural net's role to learning a feasible, monotone, coalition-dependent pricing function.

3. Use of Analytical Priors and Cost Function Design

The prior $F$ (cumulative distribution function) on agent valuations is utilized to construct a differentiable, expectation-based surrogate loss:

• For each batch iteration:
  1. Select agent $i$ and sample $v_{-i} \sim F$.
  2. The off-network routine computes for agent $i$: coalition indicator $b^*$, the two possible outcomes—$O_s$ (accept) and $O_f$ (reject)—and the cost share $c_i = OUT(b^*)_i$.

• The single-agent loss is

$$\ell_1(i; v_{-i}) = -[ (1 - F(c_i))O_s + F(c_i) O_f ]$$

where $F$ is the CDF and $O_s$, $O_f$ respectively denote the number of consumers if $i$ accepts/rejects.

• The loss is averaged over the batch and added to monotonicity penalties:

$$L = \frac{1}{B} \sum_{b=1}^B \ell_1(i^{(b)}, v_{-i}^{(b)}) + \lambda_{mon} \sum_{(b, b')} \mathrm{Penalty}_{monotone}(b, b')$$

Backpropagation utilizes the analytic form of $F$ (and its PDF $f$), crucial for efficient, stable training in deep neural architectures.

4. Supervised Initialization and Training Regime

Training is improved by a "supervision then gradient descent" protocol:

• Supervised phase: For the initial $T_0$ iterations, learning minimizes MSE between $OUT(b)$ and manual cost shares $c_{manual}(b)$, using known mechanisms as teacher labels:
  • Serial Cost Sharing (SCS): $OUT(b)_j = 1/|b|$ for $j \in b$.
  • One-directional DP ("Dynamic Programming").
  • Myopic mechanisms (may violate monotonicity).
• This supervised warm start stabilizes and accelerates subsequent unconstrained optimization.
• Gradient-based phase: After the supervised phase, pure PORF-style RL/gradient descent proceeds, leveraging the analytical prior gradients and monotonicity penalties.

Training follows standard deep learning practice (e.g., Adam optimizer), with the main loss augmented by feasibility regularizers.

5. Inference and Mechanism Execution

At inference, the PORF mechanism is executed via the following procedure:

1. Initialize $b = (1, 1, \ldots, 1)$ (all agents present).
2. Iterate up to $n$ times:
   • Query $c = OUT(b)$.
   • Find any $i$ with $v_i < c_i$ (objector). If none, termination is unanimous.
   • Else, set $b_i = 0$ and repeat.
3. The final coalition $b$ determines the served set $S^* = \{i: b_i = 1\}$ and the cost shares $OUT(b)_i$.

This algorithm implements the standard "drop-one-objector-at-a-time" logic in a clean and computationally efficient manner, requiring $O(n)$ queries to the neural network.

6. Summary of Key PORF Encoding Techniques

Essential elements of the PORF neural network approach for public project problems include:

• Off-network encoding of iterative coalition logic, isolating combinatorial search from the learning function.
• Focused learning of coalition-dependent price functions via MLP, with input encoding relying on binary coalition masks.
• Incorporation of the prior's analytical form into the differentiable objective to enable stable, effective training.
• Monotonicity and feasibility enforced by network output post-processing and gradient penalties.
• Supervised warm-start using known manual mechanisms to yield rapid and reliable convergence.
• Efficient inference via iterative agent exclusion based solely on neural network output and coalition status.

With this architecture, PORF encoding achieves a balance of computational tractability, strategy-proofness, individual rationality, and near-optimal public project provision for arbitrary continuous priors in a deep learning framework (Wang et al., 2020).