🤖 machine learning

GPU-Accelerated Inverse Structural Anastylosis from Block Collapse Dynamics

This paper introduces Jenga Inverse Predictor (JIP-2), a GPU-accelerated deep learning framework that leverages rigid-body physics simulations and a dual-stream ResNet-18 architecture to automatically reconstruct the original configurations of collapsed architectural monuments by predicting block removal sequences and stability metrics from images of debris.

Original authors: L. A. Muñoz

Published 2026-06-30

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: L. A. Muñoz

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

The Big Idea: Solving a 3D Puzzle Backwards

Imagine you walk into a room and see a pile of wooden blocks scattered on the floor. You know they used to be a tall tower, but you don't know exactly how they were stacked or which ones were pulled out to make it fall.

This paper is about teaching a computer to look at that messy pile and say, "Ah, I know exactly how this tower was built, and I can show you a video of it being taken apart and then put back together."

The authors call this "Inverse Anastylosis." In plain English, it's reverse-engineering a collapse.

The "Training Ground": The Game of Jenga

To teach the computer how to do this, the authors didn't use real ancient ruins (which are too messy and unique). Instead, they used the game Jenga.

Think of Jenga as the "lab rat" for this research.

The Rules: Jenga blocks are all the same size and shape. They stack in a predictable pattern (three blocks per layer, alternating directions).
The Physics: When you pull a block out, the tower might wobble, or it might crash. The authors used real-world physics equations (developed by a researcher named Ziglar) to simulate exactly how wood blocks slide, stick, and tip over based on friction.

How the Computer Learned (The "Brain")

The researchers built a computer program with two main parts: a Physics Simulator and a Neural Network (a type of AI).

The Simulator (The "Actor"):
The computer ran 450 different Jenga games on a super-fast graphics card (GPU). It simulated pulling blocks out, watching the tower wobble, and recording exactly how it fell. It did this with different "friction" settings (like how smooth or rough the wood is).
- Analogy: Imagine a movie director running the same scene 450 times, changing the lighting and the actors' movements slightly, just to see every possible way the scene could end.
The Neural Network (The "Detective"):
The computer took photos of the final mess (the fallen blocks) and tried to guess what happened before the crash. It had to answer four specific questions:
- How many blocks were pulled out? (Did the game end early or late?)
- Where were they pulled from? (Was it the bottom layer or the top?)
- Was the tower off-balance? (Did the center of gravity shift too far?)
- Was there a "dangerous move"? (Did someone pull a block sideways in a way that created a twisting force, like a torque?)
The AI learned to spot patterns. For example, it learned that if the blocks are scattered widely, many were likely removed. If the blocks are tilted in a specific direction, it means a "twisting" move happened earlier.

The Magic Trick: Reversing Time

Once the AI analyzed a photo of a collapsed tower, it didn't just guess; it reconstructed the story.

The Search: The AI looked through its library of 450 simulated games to find the one that looked most like the photo it was given.
The Rewind: Once it found the matching game, it took the video of that game and played it backwards.
The Result: The output is a smooth video showing the scattered blocks magically flying back up, slotting into place, and reforming the perfect tower.

Why This Matters (According to the Paper)

The authors explain that this method is a prototype for helping archaeologists.

The Real-World Problem: At ancient sites like Uxmal in Mexico, there are piles of fallen stone blocks from collapsed temples. Archaeologists have to guess how to put them back together, which is slow and hard.
The Connection: Just like Jenga blocks, stone blocks follow the laws of physics. If you know how they fell, you can figure out how they stood.
The Goal: The paper suggests that if you can teach a computer to "reverse" a Jenga collapse, you can eventually teach it to "reverse" a stone ruin collapse, helping experts reconstruct ancient history faster.

Summary in One Sentence

This paper teaches a computer to look at a pile of fallen Jenga blocks, use physics and AI to figure out exactly how the tower was taken apart, and then generate a video showing the tower being rebuilt from the rubble.

Technical Summary: GPU-Accelerated Inverse Structural Anastylosis from Block Collapse Dynamics

1. Problem Formulation

The paper addresses structural anastylosis, the conservation challenge of reassembling collapsed architectural monuments from scattered debris. While traditional methods rely on manual, subjective expert judgment, this work reframes anastylosis as an inverse prediction problem: given a static image of a collapsed state (the final configuration), recover the original structural configuration (the initial state) and the sequence of events leading to the collapse.

To make this problem computationally tractable, the authors use the game of Jenga as a physical proxy. Jenga provides a controlled environment with fixed geometric proportions (length:width:thickness ≈ 3:1:0.6) and well-defined rigid-body dynamics. The core challenge is to learn a structural prior distribution over valid tower configurations from visual observations of collapse, bypassing the need for explicit surface matching or fracture analysis which often fails in weathered archaeological contexts.

2. Methodology

The proposed framework, Jenga Inverse Predictor v2, integrates a high-fidelity physics simulation engine with a deep learning model. The pipeline consists of four main components:

A. Physics Engine and Simulation

A custom rigid-body physics engine was implemented to simulate block dynamics, adhering to the analytical mechanics derived by Ziglar (2006).

Collision Detection: Utilizes a two-phase approach. The broadphase employs GPU-accelerated Axis-Aligned Bounding Boxes (AABB) via CuPy. The narrowphase uses the Separating Axis Theorem (SAT) with Oriented Bounding Boxes (OBB) and Sutherland–Hodgman clipping to generate contact manifolds.
Contact Solver: Implements a Projected Gauss-Seidel (PGS) solver with discrete Coulomb friction. The solver runs 14 iterations per time step to resolve normal impulses and friction constraints, ensuring stability.
Dynamics: The system uses semi-implicit Euler integration with sub-stepping ( $\Delta t = 1/240$ $Δ t = 1/240$ s). It enforces Ziglar's mechanical thresholds for block removal:
- Y-axis translation (Side block): $F_{app} = 3\mu_s mg$ (Torque-free).
- X-axis translation (Side block): $F_{app} = 4\mu_s mg$ (Torque risk).
Collapse Criteria: A composite criterion triggers collapse detection based on maximum displacement ( $\Delta x_{max}$ ), kinetic energy ( $E_k$ ), and rotation angle ( $\theta_{max}$ ).

B. Data Generation

The system generated 450 simulated episodes across three static friction coefficients ( $\mu_s \in \{0.25, 0.40, 0.60\}$ ). Each episode records the full temporal sequence of block removals, the resulting collapse, and the final scattered state.

C. Neural Network Architecture

The learning component is a dual-stream ResNet-18 adapted for grayscale images and friction injection.

Backbone: A ResNet-18 backbone (modified to accept 1-channel grayscale input) extracts visual features, producing a 128-dimensional embedding.
Friction Injection: A one-hot vector representing the friction level ( $\mu_s$ ) is projected and concatenated with the visual embedding, allowing a single model to generalize across different material properties.
Multi-Task Heads: The network predicts four outputs simultaneously:
1. Number of blocks removed (Scalar, MSE loss).
2. Removal locations (Heat map of removal probabilities per block position, BCE loss).
3. Center-of-Mass (COM) imbalance (Scalar, MSE loss).
4. Accumulated torque risk (Scalar, MSE loss, predicting the count of dangerous X-axis moves).

D. Inverse Reconstruction

To reconstruct the collapse sequence from a single image, the system employs a Reference Episode Search Algorithm. It matches the model's predictions (e.g., number of removed blocks, friction level) against the database of simulated episodes. Once a matching episode is identified, the system reverses its temporal frames to generate a video of the tower being rebuilt, effectively visualizing the inverse anastylosis process.

3. Key Contributions

Inverse Anastylosis Framework: The paper proposes a novel approach to anastylosis that learns structural priors from collapse dynamics rather than relying on geometric surface matching.
GPU-Accelerated Physics: Implementation of a complete rigid-body engine (OBB/SAT + PGS) accelerated via Numba JIT and CuPy, capable of simulating complex block interactions with <1% numerical error compared to analytical solutions.
Physics-Informed Deep Learning: A ResNet-18 architecture that explicitly injects physical parameters (friction) and predicts physical quantities (torque risk, COM imbalance) alongside visual features.
Validation of Ziglar's Mechanics: The simulation validates Ziglar's (2006) analytical thresholds, confirming that X-axis moves generate significantly higher torque and collapse risk than Y-axis moves, and that higher friction stabilizes the tower but increases the danger of torque-inducing moves.

4. Results and Analysis

Simulation Fidelity: The physics engine successfully reproduced the analytical thresholds for block sliding and torque ( $F_{app} = 0.23$ N for Y-axis, $0.307$ N for X-axis with $\mu_s=0.4$ ).
Model Performance: The trained model successfully deduced the number of removed blocks, their locations, and the torque risk from static images of collapsed towers.
Friction Generalization: The friction injection mechanism allowed the model to distinguish between different material conditions ( $\mu_s = 0.25, 0.40, 0.60$ ) without retraining, as evidenced by the separation of embeddings in t-SNE visualizations.
Reconstruction: The system successfully generated smooth 3-D videos of the inverse reconstruction by retrieving and reversing the most similar simulated episode.

5. Significance and Claims

The paper claims to demonstrate that inverse structural anastylosis is solvable via machine learning when grounded in rigorous physics simulation. The authors assert that:

A complete rigid-body physics engine can be implemented to respect analytical equations with high precision.
Neural networks can learn to "see" the past of a collapse by analyzing the rubble of the present, mapping visual debris patterns to physical parameters (move count, positions, torque risk).
The proposed method offers a computational backbone for digital heritage, specifically citing potential application at the UNESCO Maya site of Uxmal, where hundreds of architectural mounds require reconstruction.

The work positions itself as a bridge between computer vision, rigid-body dynamics, and archaeological conservation, suggesting that while the current implementation uses Jenga as a proxy, the underlying principles (learning structural priors from collapse dynamics) are directly transferable to real-world stone block reassembly, provided that 3-D block detection and specific wall typologies are incorporated.