Constraining LLM Hallucinations

• The Core Domain & Meaning: The AI grasps the overall business or technical logic the diagram represents (e.g., an e-commerce checkout flow or a bank account lifecycle).
• Entity Types and Data: In class diagrams, it identifies classes, interfaces, abstract classes, fields, data types, and method signatures. In state diagrams, it identifies states, composite states, and historical states.
• Relationship Significance: The AI accurately distinguishes between complex relationship types like inheritance (is-a), composition (strong ownership), aggregation (weak ownership), and dependency (uses).
• Behavior and Triggers: In state diagrams, it reads transition arrows to identify the exact events, triggers, or guard conditions required to move from one state to another.

• Generate Code: Write fully functional object-oriented code (in Java, Python, C++, etc.) that perfectly matches the class structure.
• Find Logic Flaws: Identify dead states, infinite loops, missing edge cases, or broken architectural patterns (like tight coupling).
• Write Tests: Create unit tests or integration tests based on the states and transitions described.
• Translate Documentation: Turn the diagram into a clear, non-technical markdown document explaining how the system works.

• Example prompt:"You are a code generator. You must strictly adhere to the attached PlantUML class diagram. Any class, method, or relationship you invent outside of this specification is a critical failure."
• How it works: The LLM uses its attention mechanism to weight its tokens against the structural rules of the diagram.

• How it works: Tools like Outlines, Guidance, or instructor intercept the LLM’s token probabilities at token-generation time. If the AI tries to generate code or a state transition that violates the UML-derived schema, that token’s probability is forced to 0.

• How it works: The LLM generates code or a business workflow. A deterministic script reads the output and compiles it against a strict UML validation tool. If a constraint is violated (e.g., a state bypasses a guard condition), the exact compilation error is fed back to the LLM to self-correct.

• For QFD (House of Quality): An LLM can take unstructured customer inputs (“Voice of the Customer”) and systematically map them to a structured matrix of Technical Requirements, assigning relative weights and identifying positive/negative correlations. [6, 7]
• For TRIZ: LLMs excel at identifying technical and physical contradictions (e.g., “improving the speed of the engine worsens its weight”). They can translate these contradictions into standard TRIZ parameters, query their internal model of the TRIZ Contradiction Matrix, and output solutions grounded in the 40 Inventive Principles (such as Segmentation, Inversion, or Asymmetry). Recent research benchmarks (like TRIZBench) prove that advanced LLMs perform structured engineering ideation remarkably well when guided by these exact loops. [8, 9, 10]

[User Goal] ──> [ Tier 1: State Machine / Guardrails ] (Ensures exact process sequence)
                       │
                       ▼
                [ Tier 2: LLM Multi-Agent Flow ]      (Applies QFD/TRIZ methodologies)
                       │
                       ▼
                [ Tier 3: Constrained Decoding ]     (Enforces hard logical syntax/grammar)

• The system configuration prevents the AI from generating a solution (TRIZ step) until a symbolic verification loop confirms that the QFD step (identifying customer requirements) has successfully generated a populated matrix. [6]
• The engine mathematically cannot “skip steps” because the output of State $A$ acts as a strict structural validation key required to unlock the API call for State $B$. [13]

• Agent 1 (The QFD Analyst): Translates requirements into technical parameters.
• Agent 2 (The TRIZ Contradiction Finder): Strictly flags conflicts within Agent 1’s parameters.
• Agent 3 (The Black Belt Critic): An “LLM-as-a-Judge” agent trained to evaluate the output strictly against Six Sigma boundaries (e.g., assessing defect probabilities or process variance). If a constraint is violated, it feeds the output back into the loop for self-correction. [7, 9, 14]

• You define the structure of a QFD matrix using a programmatic data framework (like a Pydantic model or JSON Schema).
• During generation, the decoding engine alters the LLM’s token probability matrix. If the LLM attempts to generate “conversational fluff” or out-of-order text instead of a strictly valid engineering vector, that path is blocked. The output is guaranteed to be computationally sound. [12, 15]