Hierarchical Rectangle Packing Problem

• The topic is a generalization of 2D packing that organizes nested blocks with endogenous dimensions for efficient layout design.
• It employs exact mixed-integer programming models and a multi-level recursive LBBD framework to systematically refine solutions.
• Empirical results demonstrate that LBBD outperforms monolithic and bottom-up methods, reducing perimeter and area gaps significantly.

The hierarchical rectangle packing problem (2DHRP) is a generalization of classical two-dimensional packing in which the problem structure is recursively nested: blocks contain rectangles and sub-blocks, themselves defined by further packing constraints. This arises in analog circuit layout, facility arrangement, and modular logistics, where modules, boxes, or components are themselves containers for smaller components. Unlike strip or bin packing, container dimensions are not fixed a priori, and each block’s feasible dimensions are endogenously determined by solutions to embedded packing problems on child blocks. The complexity is compounded by selectable variants for rectangles and the necessity for solutions at multiple levels of granularity. Recent work formalizes exact mixed-integer and constraint programming models and demonstrates that direct monolithic approaches are computationally prohibitive beyond modest hierarchy depth. To address this, a multi-level recursive logic-based Benders decomposition (LBBD) framework has been developed, offering a scalable and systematic method for block-wise solution refinement and cut generation (Grus et al., 23 Dec 2025).

1. Mathematical Modeling: Block Structure and Constraints

Each hierarchical rectangle packing instance is defined by a rooted tree of blocks $B_1$ (top block), $B_2,\ldots,B_n$. Each block $B_i$ contains:

• A multiset $R_i = \{R_{ij}\}$ of $m_i$ leaf rectangles, possibly with a set of selectable variants as occurs in circuit modules.
• A multiset $\mathcal{C}_i = \{I_i^k\}$ representing $n_i$ occurrences of child blocks. Each occurrence references some child block $B_{i'}$ via $\text{ref}(i,k)$.

Variables for block $B_i$ include:

• Container dimensions: $W_i, H_i \in \mathbb{Z}_+$.
• For each component $O\in R_i \cup \mathcal{C}_i$, local coordinates $x_O^i, y_O^i$, width $w_O^i$, and height $h_O^i$.
• Relative-position binaries $r_{u,v}^{i,\ell}$ encoding the spatial relationship between pairs of objects for non-overlap using a big-M formulation.
• Rectangle variant-selection binaries $s_{j,t}^i$.

Key constraints include containment (objects fit within their block), non-overlap (enforced by big-M constraints and at least one of four possible spatial relationships), child-block sizing (block occurrence sizes tied to those of the referenced children), variant selection, and optional cycle elimination/topological order constraints to preclude solution degeneracy.

The full monolithic MILP formulation (M-MILP) minimizes container perimeter $W_1 + H_1$ (or area), subject to all block-wise constraints and piecewise-linear relaxations indicating lower bounds derived from aggregate child/rectangle areas.

2. Logic-Based Benders Decomposition: Master and Subproblem Partitioning

At the heart of LBBD for 2DHRP is the partitioning of block $B_i$’s packing into:

• Master Problem $M_i$: This problem determines $W_i, H_i$, local object positions, and block occurrence variables, while treating child block dimensions $(W_{i'}, H_{i'})$ as plan variables not yet guaranteed to be feasible. Constraints on $M_i$ include all block-level relationships plus any accumulated Benders cuts from prior infeasible subproblems.
• Subproblem (per child block): For each referenced child $B_{i'}$, the subproblem checks whether a feasible packing exists with width at most $W_{i'}^{\mathrm{PLAN}}$. It minimizes $H_{i'}$ subject to $B_{i'}$'s packing constraints.

The decomposition recursively proceeds with parents proposing width envelopes to children, and children returning either feasible packings or infeasibility certificates. The information flow is bi-directional, enabling dynamic refinement of feasible dimension domains at each level.

3. Cut Generation and Recursive Refinement

Whenever subproblem $B_{i'}$ returns $W_{i'}^{\mathrm{ACT}} > W_{i'}^{\mathrm{PLAN}}$, the master problem at $B_i$ is updated by appending a cut of the following logic-based form:

$$W_{i'} \le W_{i'}^{\mathrm{PLAN}} \;\Rightarrow\; H_{i'} \ge H_{i'}^{\mathrm{ACT}}$$

This eliminates candidate plans assigning infeasible width $W_{i'}^{\mathrm{PLAN}}$ unless the height $H_{i'}$ is at least the minimal feasible height found. All cuts are local to the block in question and only restrict the candidate (width, height) pairs for block occurrences. These cuts are linear and compatible with MILP or CP solvers.

The process is carried out recursively: the top block proposes global container width (unbounded), solves its master, and calls subproblems at each child for each candidate plan until feasible dimension assignments propagate to all leaves.

Optional fine-tuning operations, such as “left-shift” (minimizing width subject to known feasible heights) and “right-expand” (minimizing height given previously discovered feasible widths), further exploit feasible envelopes and tighten solution quality.

4. Algorithmic Workflow and Convergence Properties

The multi-level recursive LBBD proceeds in the following steps (summarized from (Grus et al., 23 Dec 2025)):

1. Initialization: For each block, initialize the set of Benders cuts.
2. Master Solve: Solve master $M_i$ minimizing $H_i$ subject to all current cuts and plan variables.
3. Packing Subproblems: For each child occurrence, attempt to pack the child block under the proposed width; return actual dimensions or report infeasibility.
4. Cut Addition: For any infeasible subproblem, append the corresponding logic-based Benders cut to restrict the parent’s width-height envelope over its child.
5. Recursion/Fine-Tuning: If all children are feasible, accept the solution. Otherwise, repeat the master-subproblem loop until no improvement or global time limit is reached.

Convergence is guaranteed in the exact version because each Benders cut strictly reduces the feasible domain for candidate plans at the violating (width, height) and the space of integer box dimensions is finite. A plausible implication is that practical variants incorporating early termination and improvement intervals yield high-quality solutions without full enumeration.

5. Empirical Performance and Baseline Comparisons

Comprehensive experiments on synthetic instances of up to seven hierarchy levels and hundreds of rectangles per block benchmarked the LBBD approach against:

• Monolithic CP and MILP models: These methods were unable to improve beyond trivial lower bounds at deeper hierarchies due to excessive computational requirements.
• Bottom-Up (BU) heuristic methods: These approaches required manual tuning of the number of candidate width/height variants per block and time-slice scheduling for subblock solutions. Performance was highly sensitive to these parameters.
• Multi-level LBBD methods: Consistently achieved superior solution quality and scalability with minimal parameter tuning. LBBD reduced half-perimeter gaps to 2–6% and area gaps to 5–12% relative to lower bounds, outperforming BU across almost all tested instances.

Empirical solution times for multi-level LBBD were typically a few minutes on moderate instances, scaling to hours for the deepest and largest hierarchies only. The method’s dynamic cut generation eliminated the need for pre-generating aspect ratio candidate pools.

6. Generalization and Applicability

The multi-level recursive LBBD paradigm directly models the information and constraint flow of hierarchical packing and extends naturally to other domains involving nested packing, scheduling, or assignment problems. The generic logic-based cut formulation is solver-agnostic and applicable wherever a master solution proposes a bounding envelope for recursively defined subproblems, and child subproblems can generate valid linear cuts upon failing to deliver feasible packings under prescribed dimensions.

Dynamic refinement via logic-based cuts replaces reliance on exhaustive pre-generation of candidate dimensions and eliminates manual selection of aspect ratios, directly improving solution efficiency and eliminating parameter sensitivity. The recursive structure allows code reuse and modular composition at each hierarchy level without explicit reference to global problem complexity.

• Grus, J., Hanzálek, Z., Artigues, C., Briand, C., Hebrard, E. (2024). “Hierarchical Rectangle Packing Solved by Multi‐Level Recursive Logic‐based Benders Decomposition,” Computers & Operations Research 167 (2024), (Grus et al., 23 Dec 2025).