The Deterministic Divide: Why LLMs Guess Pixels While Physics-Informed Graphs Calculate Loads

Executive Summary: The Balcony Paradox

The architectural, engineering, and construction (AEC) industry currently stands at the precipice of a technological schism, one that will define the safety profile of our built environment for the next century. On one side lies the seductive promise of Generative AI—Large Language Models (LLMs) and Multimodal Large Language Models (MLLMs) that can seemingly "read" blueprints, generate design concepts, and converse about building codes with human-like fluency. On the other side lies the rigorous, immutable reality of physics. A balcony does not stand because a text description says it is "robust," nor does it resist gravity because a pixel-based analysis identifies the visual presence of a railing. It stands only if the load path is continuous, the stress distribution remains within the elastic limit of the materials, and the topology of the structure satisfies the governing differential equations of equilibrium.

This whitepaper, prepared for Veriprajna, investigates the fundamental divergence between Pixel-Based Probabilistic AI (the current wave of Generative AI) and Structure-Based Deterministic AI (Veriprajna's approach using Geometric Deep Learning). We explore the foundational weakness of applying Euclidean neural architectures—such as Vision Transformers—to the non-Euclidean reality of structural engineering. We demonstrate through rigorous analysis of recent benchmarks why Multimodal LLMs, despite their linguistic prowess, are prone to dangerous hallucinations when tasked with structural reasoning. They view a blueprint as a collection of pixels to be predicted; they do not calculate the loads those pixels represent.

In contrast, we present a comprehensive framework for Geometric Deep Learning (GDL) and Physics-Informed Neural Networks (PINNs) . This approach converts engineering schematics not into tokens, but into mathematical Graphs where nodes act as structural members and edges function as load paths. By embedding the laws of physics directly into the neural network's loss functions, we move from the probabilistic guessing of "Is this safe?" to the deterministic calculation of "Will this hold?"

The industry faces a critical question, one that Veriprajna answers with mathematical certainty: Are you building on a foundation of math, or probability?

1. The Hallucination of Safety: Why Multimodal LLMs Fail at Structural Reasoning

The rapid proliferation of Large Language Models has led to a dangerous conflation of plausibility with accuracy . In the domain of creative writing or marketing copy, a plausible answer is often sufficient. In structural engineering, a plausible but incorrect answer is catastrophic. The core failure mode of deploying LLMs for structural analysis lies in their architecture: they are probabilistic engines designed to predict the next token or pixel, not logic engines designed to solve physical constraints.

1.1 The Pixel-Based Trap: Vision Transformers and the Illusion of Understanding

When a Multimodal LLM, such as GPT-4V or Gemini, "sees" a structural blueprint, it does not perceive beams, columns, or load paths. It employs a Vision Transformer (ViT) architecture to process the image. The ViT divides the image into a sequence of fixed-size patches (e.g., $16 \times 16$ pixels), flattens them into vectors, and processes them to minimize a training loss. ¹

Crucially, recent theoretical research reveals that ViTs minimize this loss by learning "patch associations"—statistical correlations between clusters of pixels—rather than true spatial topology. ¹ The model might learn that a patch containing a vertical line (a column) is statistically likely to be adjacent to a patch containing a horizontal line (a beam). However, this is a correlation, not a causal understanding. The model does not understand that the horizontal line is supported by the vertical line. If the vertical line is removed, the model’s probabilistic distribution might shift slightly, but it has no internal physics engine to tell it that the horizontal line must now fall.

This "bag of patches" approach explains why LLMs struggle with precise spatial reasoning. In experiments where image pixels or patches are permuted (scrambled), ViTs often retain high classification accuracy, proving that they are not relying on the strict spatial structure of the object but on the presence of texture and local patterns. ¹ In engineering, however, spatial structure is everything. A connection detail that is "mostly there" but missing a critical load path continuity is not 90% safe; it is 100% unsafe. By treating blueprints as pixels, LLMs fundamentally miss the binary nature of structural stability.

Feature	Vision Transformer (LLM)	Engineering Reality
Input Unit	Pixel Patch ($16 \times 16$ grid)	Structural Element (Beam, Column)

Relationship	Statistical Correlation (Atet ntion)	Physical Causality (Load Transfer)
Spatial Understanding	Positional Embedding (Learned)	Topological Connectivity (Absolute)
Failure Mode	Hallucination (Looks safe)	Collapse (Is unsafe)
Data Domain	Euclidean (Grid-like)	Non-Euclidean (Graph-like)

1.2 The DSR-Bench Verdict: Quantifying the Reasoning Gap

The hypothesis that LLMs struggle with structural reasoning is not merely theoretical; it has been empirically validated. The DSR-Bench (Data Structure Reasoning Benchmark) recently evaluated the algorithmic reasoning capabilities of ten state-of-the-art LLMs across 35 operations and 4,140 synthetically generated problem instances. ³ The results were sobering for any proponent of LLM-based engineering.

The benchmark was designed to test "structural reasoning"—the ability to understand and manipulate complex relationships between entities, a direct proxy for understanding a building's frame.

●​ Performance Ceiling: The top-performing frontier model achieved a score of only 0.498 out of 1.0 on challenging instances involving hybrid and compositional structures. ³

●​ Failure Modes: The models displayed critical weaknesses in multi-hop reasoning (tracing a relationship through multiple intermediate nodes) and constraint satisfaction (adhering to strict user-defined rules).

●​ Spatial Incompetence: On spatial data tasks—which mimic the multi-dimensional nature of real-world physical structures—performance dropped significantly as dimensionality increased. ³

Most alarmingly, the study found that model performance degrades when problems are described in "natural language" compared to formal code. This suggests that LLMs rely on pattern-matching specific syntactical structures (memorized from training data like GitHub) rather than engaging in genuine reasoning. When an engineer describes a unique, non-standard structural problem in plain English, the LLM is forced out of its memorized patterns and into a reasoning mode where it statistically fails 50% of the time. ³

1.3 The DesignQA Evidence: Inability to Verify Requirements

Further evidence comes from DesignQA, a benchmark specifically constructed to evaluate MLLMs in engineering design contexts. ⁴ This study focused on the ability of models to extract technical requirements from documentation and apply them to design artifacts.

The findings reinforced the "illusion of competence." While MLLMs could fluently summarize the text of a building code or engineering standard, they failed to accurately apply those quantitative constraints to the design visual.

●​ Extraction vs. Application: The models could answer "What is the maximum allowed deflection?" (Extraction) but failed to answer "Does this specific beam design meet the maximum allowed deflection?" (Application). ⁴

●​ Exotic Bias: Research into material selection found that LLMs exhibited a strong bias toward "exotic" or high-performance materials (like titanium or carbon fiber) even when the context demanded cost-effective solutions, simply because those materials appear frequently in the "high-tech" training corpus. ⁵

This bias towards "optimal-sounding" but contextually wrong answers highlights the hallucination risk. An LLM reviewing a balcony design might suggest a high-strength alloy railing—sounding very professional—while failing to notice that the concrete cantilever slab lacks top reinforcement, the actual cause of the theoretical collapse.

1.4 The "Stochastic Parrot" in a Deterministic World

The fundamental issue is the mismatch of domains. Structural engineering is a deterministic field governed by the laws of physics. If $\sum F_y \neq 0$, the structure accelerates. There is no probability involved. LLMs are stochastic engines. They generate text based on the probability distribution of the next token.

When we ask an LLM, "Is this balcony safe?", it is not calculating a moment of inertia. It is predicting the tokens that typically follow that question in its training data. If its training data contains thousands of safety inspection reports that conclude "the structure appears sound," the LLM is statistically biased to generate a similar reassurance, regardless of the visual evidence in the specific pixel patch it is analyzing. It is guessing based on the "vibe" of the pixels, not the calculus of the loads.

2. Geometric Deep Learning: The Mathematical Foundation of Veriprajna

To transcend the limitations of pixel-guessing, Veriprajna builds upon Geometric Deep Learning (GDL) . This field of Artificial Intelligence generalizes neural networks to non-Euclidean domains, specifically graphs and manifolds. ⁶ In our framework, a building is not an image; it is a Graph .

2.1 The Non-Euclidean Reality of Structures

Standard Deep Learning (CNNS) operates on Euclidean data . Images are 2D grids; audio is a 1D grid (time). In Euclidean space, the concept of "direction" and "neighbor" is fixed. A pixel at $(x,y)$ always has exactly 8 neighbors (unless at the edge), and the shift from $(x,y)$ to $(x+1, y)$ is uniform everywhere. ⁷

Structures are inherently Non-Euclidean .

●​ Irregular Topology: A steel node in a truss might connect to 3 members; a node in a complex diagrid might connect to 8. There is no fixed "grid."

●​ No Fixed Orientation: A beam is defined by its connectivity, not its position in a bitmap.

Rotating a blueprint 90 degrees changes every pixel value, breaking a standard CNN, but the underlying Graph (the connections between members) remains invariant. ⁷

Veriprajna utilizes Graph Neural Networks (GNNs) because they are mathematically designed to handle this irregularity. A GNN does not force the structure into a grid; it accepts the structure as a set of nodes ($V$) and edges ($E$) in its native topological format. ⁶

2.2 Mathematical Definition of the Building Graph

In the Veriprajna system, a structural model is formalized as a graph $G = (V, E)$.

Nodes ($V$): Each node represents a physical structural component (Beam, Column, Slab, Wall). Unlike a pixel which contains only color data (RGB), a Veriprajna node is a rich data container holding a feature vector $\mathbf{x}_v$:

$$\mathbf{x}_v =$$

These features capture the Young’s Modulus ($E$), Moment of Inertia ($I$), and Yield Strength ($f_y$)—the actual physical parameters required for calculation.10 Edges ($E$): Each edge represents a physical connection or interaction. An edge $e_{ij}$ exists if Member $i$ transfers load to Member $j$. The edge feature vector $\mathbf{x}_{e_{ij}}$ captures the connection stiffness (fixed vs. pinned) and relative orientation.

$$\mathbf{x}_{e_{ij}} =$$

This representation is permutation invariant . The physics of the building does not change if we reorder the list of beams in the database. GNNs respect this invariance, whereas Sequence models (like the Transformers in LLMs) are sensitive to input order. ⁷

2.3 Graph Convolution and Message Passing

The engine of Veriprajna’s reasoning is the Message Passing Neural Network (MPNN) paradigm. In a GNN, information flows through the graph similarly to how forces flow through a structure.

For every layer $l$ of the GNN, the state of a node $\mathbf{h}_v^{(l)}$ is updated by aggregating "messages" from its neighbors $\mathcal{N}(v)$:

$$\mathbf{h}_v^{(l+1)} = \phi^{(l)} \left( \mathbf{h}_v^{(l)}, \bigoplus_{u \in \mathcal{N}(v)} \psi^{(l)} \left( \mathbf{h}_u^{(l)}, \mathbf{h}_v^{(l)}, \mathbf{e}_{uv} \right) \right)$$

●​ $\psi^{(l)}$: The Message Function . In structural terms, this computes the force/moment transferred from neighbor $u$ to node $v$.

●​ $\bigoplus$: The Aggregation Function (e.g., Sum). This sums up all the forces acting on node $v$ from all connected members.

●​ $\phi^{(l)}$: The Update Function . This computes the new state (e.g., displacement or stress) of node $v$ based on the total incoming force.

By stacking $k$ layers of GNNs, the network propagates information $k$-hops away. A 10-layer GNN allows a load applied on the roof (Node A) to mathematically influence the state of the foundation (Node Z), mimicking the global load path distribution of the actual physical structure. ⁶

This is not a visual guess. It is a learnable, differentiable simulation of the load path.

3. From BIM to Graph: The Veriprajna Data Pipeline

The transition from a static BIM model or a 2D blueprint to a dynamic computation graph is the core technical differentiator of Veriprajna. While LLMs attempt to read the "image" of the blueprint, our pipeline extracts the "logic" of the schema.

3.1 Graph Representation Learning for BIM

Building Information Modeling (BIM) data, usually in IFC format, contains the necessary information but in a hierarchical, object-oriented format that is unsuitable for direct Machine Learning. Veriprajna employs a Graph Representation Learning workflow to transform this data. ¹⁰

Step 1: Topological Extraction We utilize an IFC-to-BIMGraph converter that parses the IFC schema. It identifies relationships such as IfcRelConnectsElements (physical connection) and IfcRelContainedInSpatialStructure (spatial hierarchy). These relations are directly mapped to the edges of our graph. Unlike LLMs which struggle to "see" if two lines touch, the IFC schema defines this connectivity explicitly, and our parser captures it with 100% fidelity.12

Step 2: Multimodal Node Embedding A structural member has both semantic descriptions ("IPE 300 Steel Beam") and geometric properties (the 3D mesh). We fuse these modalities into the node's feature vector 10:

●​ Semantic Embedding: We use Large Text Embedding models (or specialized ontologies like pyRDF2Vec) to convert the textual metadata into high-dimensional vectors. This allows the model to mathematically understand that "IPE 300" and "HEB 300" are similar (both steel sections) but distinct in capacity. ¹³

●​ Geometric Embedding: We employ Point Cloud Encoders (such as PointNet) to encode the 3D geometry of the element into a vector. This captures complex shapes that text cannot describe.

Step 3: Dimensionality Reduction To ensure efficient processing, we apply algorithms like t-SNE (t-distributed Stochastic Neighbor Embedding) to reduce the high-dimensional feature vectors into a compact representation that retains the critical variance without overfitting.¹³

3.2 Automated Structural Model Generation

The ultimate output of this pipeline is not a text description, but an Input File for structural analysis. Research has demonstrated that GNNs can be trained via supervised learning to map BIM entities directly to Finite Element (FE) parameters. ¹³

●​ Prediction: The GNN predicts the necessary stiffness parameters ($EI, EA$) for each node based on its embeddings.

●​ Construction: The system automatically generates the node and element definitions for solvers like OpenSees or SAP2000 .

This process automates the "Load Takedown" preparation. Instead of an engineer manually measuring tributary areas and redrawing the frame, the Veriprajna GNN traverses the graph, aggregates the area attributes of slab nodes, transfers them to beam nodes, and compiles the load matrix. ¹³

4. Physics-Informed Neural Networks (PINNs): The Engine of Determinism

The most significant criticism of AI in engineering is the "Black Box" problem. How can we trust a neural network with human safety? Veriprajna answers this with Physics-Informed Neural Networks (PINNs) . We do not ask the AI to learn physics from data; we teach the AI physics by embedding differential equations directly into its brain.

4.1 Embedding Governing Equations in the Loss Function

In a standard neural network, the training goal is to minimize the error between the prediction and the ground truth data ($\mathcal{L}_{data}$). In a PINN, we add a Physics Residual

($\mathcal{L}_{PDE}$) to the loss function. ¹⁴

Consider the Euler-Bernoulli beam equation governing the balcony:

$$\frac{\partial^2}{\partial x^2} \left( EI \frac{\partial^2 w}{\partial x^2} \right) + q(x) = 0$$

Where $w$ is deflection and $q(x)$ is the load. When training the Veriprajna model, the loss function is defined as:

$$\mathcal{L}_{total} = \mathcal{L}_{data} + \lambda \cdot \mathcal{L}_{PDE}$$

$$\mathcal{L}_{PDE} = \frac{1}{N} \sum_{i=1}^{N} \left| \frac{\partial^2}{\partial x^2} \left( EI \frac{\partial^2 \hat{w}}{\partial x^2} \right) + q(x_i) \right|^2$$

Here, $\hat{w}$ is the network's predicted deflection. We use Automatic Differentiation to compute the derivatives of the prediction exactly. If the network predicts a deflection shape that violates the laws of static equilibrium, the $\mathcal{L}_{PDE}$ term spikes, forcing the network to correct itself. ¹⁴

4.2 Case Study: The Spaghetti Bridge and Beyond

The efficacy of this approach has been proven in recent experiments, such as the prediction of load capacity for spaghetti bridges. ¹⁴ A Physics-Informed Kolmogorov Arnold Network (PIKAN) was used to predict the failure load. By integrating the physical constraints of the bridge geometry and material limits, the model could accurately predict weight limits even with sparse data.

In more complex scenarios, such as railway bridges under dynamic loads, PINNs have been successfully used to identify influence lines and predict structural responses where traditional pure-data ML models failed to converge. ¹⁵ The PINN acts as a regularizer, ensuring that the AI's "imagination" never violates Newton's laws.

4.3 Graph-Structured Physics-Informed DeepONets

Veriprajna leverages the cutting edge of this field: the Graph-Structured Physics-Informed DeepONet (GS-PI-DeepONet) . ¹⁷

●​ DeepONet (Deep Operator Network): A neural network designed to learn operators (mappings between infinite-dimensional function spaces) rather than just functions. It can learn the operator that maps a "Load Distribution Function" to a "Deflection Function."

●​ Graph-Structured: It applies this operator learning on unstructured graphs (meshes), allowing it to handle complex, irregular building geometries that standard CNNs cannot touch.

This architecture has shown 7–8x speedups compared to traditional Finite Element Method (FEM) solvers while maintaining $R^2$ accuracy values of up to 0.9999 . ¹⁷ This means Veriprajna offers the speed of AI with the precision of FEM.

5. Automated Load Path Tracking: The "Spine" of the Structure

In the "Balcony" example, the critical failure is often a discontinuity in the load path—load is applied to the cantilever, but there is no back-span or moment connection to transfer it to the column. An LLM sees pixels; Veriprajna sees the Principal Load Path .

5.1 Matrix-Based Pathfinding for Resilience

Veriprajna employs rigorous graph theory algorithms to trace load paths. The structure is represented as an Adjacency Matrix $A$.

●​ Connectivity Analysis: By raising the adjacency matrix to powers ($A^n$), we can identify all paths of length $n$ between the load application point and the foundation. ¹⁸

●​ Exhaustive Path Enumeration: We utilize a matrix-based exhaustive pathfinder that identifies all feasible paths for load transfer. This allows us to quantify the Redundancy of the structure. If only one path exists (a statically determinate system), the structure has zero redundancy and high risk. ¹⁹

5.2 The U Index: Visualizing Load Transfer*

To provide engineers with intuitive insights, we calculate the U Index *, a metric that expresses the internal strain energy transfer and relative rigidity between points. ²⁰

●​ Principal Load Path (PLP): Defined as the "ridgeline" of the U* contours—the stiffest route through the structure.

●​ Streamline Visualization: Using the Runge-Kutta (RK4) algorithm, we can integrate the gradient of the U* index to draw "streamlines" of force. ²⁰

This generates a visualization where the "spine" of the building lights up. If the balcony is safe, the PLP streamline will connect seamlessly from the railing to the column. If it is unsafe (e.g., a "floating" cantilever), the streamline will terminate abruptly or show a massive divergence in strain energy. This is a visual diagnostic derived from math, not a visual hallucination derived from training images.

5.3 Failure Propagation and Cut Sets

Current graph theory methods also allow us to model Progressive Collapse. By systematically removing nodes (simulating column failure) and re-evaluating the graph's connectivity (using measures like Betweenness Centrality or Efficiency), we can identify Cut Sets—critical clusters of components whose failure splits the graph into disconnected components.21 This "Graph Attack" simulation is computationally instant compared to re-running a non-linear FEM collapse analysis, allowing Veriprajna to screen thousands of failure scenarios in real-time.21

6. Enterprise Application: The "Verifier" Layer

For the enterprise client—the large engineering firm, the government regulator, the real estate developer—Veriprajna offers a specific deployment model. We do not aim to replace the engineer; we aim to replace the uncertainty of AI adoption.

6.1 The "Human-in-the-Loop" Workflow

The future of design involves Generative AI, but it requires a Verifier Layer .

1.​ Generative Layer (Probability): Architects use tools like Midjourney or MLLMs to generate creative concepts ("Show me a cantilevered balcony with a parametric railing"). This is the domain of probability.

2.​ Veriprajna Layer (Determinism):

○​ The concept is parsed into a BIM Graph .

○​ Topology Check: Is the graph connected? (DFS/BFS Algorithms).

○​ Load Path Check: Does the Principal Load Path reach the foundation? (U* Index).

○​ Physics Check: Do the PINN-predicted stresses satisfy $\sigma < f_y$? (PDE Loss).

3.​ Feedback: If the Physics Check fails, Veriprajna returns a hard constraint to the Generative model ("Increase beam depth by 200mm" or "Add back-span connection"), forcing a regeneration that is physically valid. ⁵

6.2 Data Efficiency and Security

A major advantage of the GNN/PINN approach is Data Efficiency . LLMs require petabytes of training data (the whole internet) to learn a "vibe" of what a building looks like. PINNs, because they are constrained by physics equations, can be trained on Small Data . ¹⁴

●​ Generalization: A GNN trained on a dataset of steel frames generalizes well to new steel frames because the underlying physics (Hooke's Law) doesn't change.

●​ Privacy: Because the models are smaller and specialized, they can be deployed On-Premise . Clients do not need to send sensitive IP (blueprints of nuclear plants or data centers) to a public API like OpenAI. The "Physics Engine" lives on your server.

6.3 Explainability: The "Glass Box"

Because Graph Neural Networks operate on nodes that map 1:1 to physical objects, they are inherently interpretable.

●​ Attention Weights: We can visualize the GNN attention weights to see exactly which neighbors influenced a node's failure prediction.

●​ Traceability: "The column failed because the load transferred from Beam A and Beam B exceeded capacity." ​

This is the Glass Box of AI, contrasting sharply with the "Black Box" of LLMs where the reasoning is hidden in billions of uninterpretable parameters.23

7. Comparative Analysis: The Veriprajna Advantage

Capability	Standard Multimodal LLM	Veriprajna (GDL/PINN)
Core Operation	Next-Token Prediction	Message Passing (Force Transfer)
Context Window	Limited Tokens (Forgetul)	Infnite Graph Connectivity
Safety Assurance	"It looks safe" (Hallucination)	"Physics Residual is roughly 0" (Verifed)
Load Pathing	Visual Estimation (Guess)	Graph Traversal (Algorithm)
Constraint Handling	Sof (Ofen ignored)	Hard (PDEs in Loss Function)
Interpretability	Black Box	Glass Box (Node-Level Atention)
Training Data	The Internet (Biased/Noisy)	Physics Equations + Structured Data

8. Conclusion: The Foundation of Math

The construction industry is unique. In software, a "bug" is an annoyance. In our industry, a "bug" is a tragedy. The hype cycle surrounding Generative AI has obscured this fundamental distinction, promising a future where AI "imagines" our cities.

Veriprajna rejects the premise that engineering should be imaginative in its verification. We assert that engineering verification must be deterministic . The "Balcony Paradox" is resolved not by training a better image recognizer, but by abandoning the image altogether in favor of the graph.

●​ ChatGPT says the balcony is safe because it has seen thousands of photos of balconies, and in those photos, the pixels of the floor usually stay above the pixels of the ground.

●​ Physics says the balcony will collapse because the bending moment at the fixed end exceeds the moment capacity of the section ($\sum M > M_{cap}$).

Veriprajna is the platform that allows you to listen to Physics. We build on the foundation of Graph Theory, Geometric Deep Learning, and Differential Equations. We do not guess pixels. We calculate loads.

Are you building on a foundation of math, or probability?

Research Data & Citations

●​ LLM Limitations: ³ (DSR-Bench structural reasoning failures) ⁴ (DesignQA requirements verification failure) ¹ (ViT Patch Associations vs Topology) ⁵ (Autodesk Generative AI benchmarks) ² (ViT Architecture).

●​ Geometric Deep Learning Fundamentals: ⁶ (GDL definition) ⁹ (GNN Notation & Math) ⁷ (Euclidean vs Non-Euclidean) ²⁵ (GNN Generalization) ⁸ (Altair PhysicsAI & GDL).

●​ Data Pipeline: ¹⁰ (BIM Graph Representation) ¹³ (Semantic Embeddings & ANNs) ¹² (IFC-to-BIMGraph) ²⁶ (GraphRAG & Ontologies).

●​ Physics-Informed Neural Networks: ¹⁴ (PINNs for Bridge Weight/PIKAN) ¹⁵ (PINN Review & Railway Bridges) ¹⁷ (Graph-Structured DeepONet) ¹⁶ (PINN for Frames).

●​ Load Path & Resilience: ¹⁹ (Matrix Pathfinding) ²¹ (Graph Theory for Pipe Failures) ¹⁸ (Adjacency Matrix Powers) ²⁰ (U* Index & Load Paths) ²⁰ (Principal Load Path Visualization).

●​ General Context: ²⁷ (Generative Drawings challenges) ²⁸ (AI Ethics & Bias) ²² (Generative vs. Non-Generative Models).

Works cited

1. Vision Transformers provably learn spatial structure, accessed December 12, 2025, https://proceedings.neurips.cc/paper_files/paper/2022/file/f69707de866eb0805683d3521756b73f-Paper-Conference.pdf

2. Vision Transformers (ViT) Tutorial: Architecture and Code Examples - DataCamp, accessed December 12, 2025, https://www.datacamp.com/tutorial/vision-transformers

3. Can LLMs Reason Structurally? An Evaluation via the Lens of Data ..., accessed December 12, 2025, https://arxiv.org/pdf/2505.24069

4. DesignQA: A Multimodal Benchmark for Evaluating Large Language Models' Understanding of Engineering Documentation - arXiv, accessed December 12, 2025, https://arxiv.org/html/2404.07917v1

5. Safer by Design: Benchmarks for Generative AI - Autodesk Research, accessed December 12, 2025, https://www.research.autodesk.com/blog/safer-by-design-benchmarks-for-generative-ai/

6. Geometric Deep Learning — AI Search Algorithms for Smart Mobility, accessed December 12, 2025, https://smartmobilityalgorithms.github.io/book/content/LearnToSearch/GeometricDeepLearning.html

7. A gentle introduction to Geometric Deep Learning - dataroots, accessed December 12, 2025, https://dataroots.io/blog/a-gentle-introduction-to-geometric

8. Geometric Deep Learning, Altair® physicsAI™, and the Next Era of AI-Powered Engineering, accessed December 12, 2025, https://altair.com/blog/executive-insights/geometric-deep-learning-ai-engineering-altair-physicsai

9. AIDA-01-Intro to geometric deep learning, accessed December 12, 2025, https://www.i-aida.org/wp-content/uploads/2022/07/AIDA-Geometric-deep-learning-part-01.pdf

10. graph representation learning: embedding multimodality bim models into graphs - European Council on Computing in Construction, accessed December 12, 2025, https://ec-3.org/publications/conferences/EC32025/papers/EC32025_286.pdf

11. Graph Network-based Structural Simulator: Graph Neural Networks for Structural Dynamics - arXiv, accessed December 12, 2025, https://arxiv.org/html/2510.25683v1

12. graph representation learning: embedding ... - mediaTUM, accessed December 12, 2025, https://mediatum.ub.tum.de/doc/1780983/hag373op3y69o9fnb4r9h3ecu.GRL_EC3_camera_ready.pdf

13. Automatic generation of Structural models from BIM models using ..., accessed December 12, 2025, https://www.ucl.ac.uk/bartlett/sites/bartlett/files/automatic_generation_of_structural_models_from_bim_models_using_semantics_and_machine_learning.pdf

14. Seeing Structural Failure Before it Happens: An Image-Based Physics-Informed Neural Network (PINN) for Spaghetti Bridge Load Prediction - arXiv, accessed December 12, 2025, https://arxiv.org/html/2510.23117

15. Physics-Informed Neural Networks for the Structural Analysis and Monitoring of Railway Bridges: A Systematic Review - ResearchGate, accessed December 12, 2025, https://www.researchgate.net/publication/391684879_Physics-Informed_Neural_Networks_for_the_Structural_Analysis_and_Monitoring_of_Railway_Bridges_A_Systematic_Review

16. Exploring the Potential of Physics-Informed Neural Networks for the Structural t b Analysis of 2D Frame Structures - MDPI, accessed December 12, 2025, https://www.mdpi.com/2673-3161/6/4/84

17. A Graph-Structured, Physics-Informed DeepONet Neural Network for ..., t b accessed December 12, 2025, https://www.mdpi.com/2504-4990/7/4/137

18. Model structure analysis through graph theory: partition heuristics and feedback structure decomposition, accessed December 12, 2025, https://www.hbs.edu/ris/Publication%20Files/04-016_1ef8720a-a749-4a7b-9db7-1527c9c9efc9.pdf

19. Graph-Theoretic Pathfinding for Infrastructure Robustness and ..., accessed December 12, 2025, https://www.jsofcivil.com/article_233020_bc0a15e4051015c95980e439af441832.tpdf

20. load path visualization using u* index and - CORE, accessed December 12, 2025, https://core.ac.uk/download/pdf/524099241.pdf

21. Modeling multiple-pipe failures in stormwater networks using graph theory - IWA Publishing, accessed December 12, 2025, https://iwaponline.com/jh/article/26/11/3027/105373/Modeling-multiple-pipe-failures-in-stormwater

22. Generative vs. Non-Generative Models in Engineering Shape Optimization t b MDPI, accessed December 12, 2025, https://www.mdpi.com/2077-1312/12/4/566

23. Using graph neural networks and frequency domain data for automated t b operational modal analysis of populations of structures | Data-Centric Engineering - Cambridge University Press & Assessment, accessed December 12, 2025, https://www.cambridge.org/core/journals/data-centric-engineering/article/using-graph-neural-networks-and-frequency-domain-data-for-automated-operational-modal-analysis-of-populations-of-structures/5834E459A2DBFE3F881EE88645BF0EA3

24. Auto-GNN: Neural architecture search of graph neural networks - PMC - PubMed t b Central, accessed December 12, 2025, https://pmc.ncbi.nlm.nih.gov/articles/PMC9714572/

25. Introduction to Geometric Deep Learning | ml-articles – Weights & Biases t b Wandb, accessed December 12, 2025, https://wandb.ai/mostafaibrahim17/ml-articles/reports/Introduction-to-Geometric-Deep-Learning--VmlldzozODY5NTE1

26. BIMConverse - GraphRAG for IFC Natural Language Queries - IAAC BLOG, t b accessed December 12, 2025, https://blog.iaac.net/bimconverse-graphrag-for-ifc-natural-language-queries/

27. Large Language Model Agent for Structural Drawing Generation Using ReAct t b Prompt Engineering and Retrieval Augmented Generation - arXiv, accessed December 12, 2025, https://arxiv.org/html/2507.19771v1

28. Responsible AI in structural engineering: a framework for ethical use - Frontiers, t b accessed December 12, 2025, https://www.frontiersin.org/journals/built-environment/articles/10.3389/fbuil.2025.1612575/full