# Requirement Diagrams

### What are Requirement Diagrams?

Mermaid's Requirement diagrams provide a structured visualization of requirements, their attributes, and their relationships to elements or other requirements. Commonly used in systems engineering, these diagrams adhere to SysML standards and offer a clear view of dependencies, risks, and verification methods. For data and analytics teams, they can be used to ensure traceability of project requirements and their implementation.

### Creating Your First Requirement Diagram

1. **Launch DinoAI:** From Code IDE, access [DinoAI](https://docs.paradime.io/app-help/documentation/dino-ai) to start creating diagrams.
2. **Use a Simple Prompt:** Tell DinoAI what kind of Requirements Diagram you want to create. For example:

{% code overflow="wrap" %}

```
- "Create a mermaid requirement diagram for my data warehouse project showing business needs and technical specs"

- "Generate a mermaid requirement diagram for my dbt™ implementation with stakeholder requirements"

- "Build a mermaid requirement diagram showing data governance requirements and their relationships"
```

{% endcode %}

3. **Get Your Diagram:** DinoAI will generate a complete `.mmd` file with proper Mermaid syntax.
4. **Preview Your Work:** Click the eye icon (👁️) to preview your diagram in real-time as you edit.
5. **Iterate and Refine:** Modify the generated `.mmd` file directly, or ask DinoAI to make specific changes.

#### Example: 

```mermaid
requirementDiagram

requirement test_req {
    id: 1
    text: the test text.
    risk: high
    verifymethod: test
}

element test_entity {
    type: simulation
}

test_entity - satisfies -> test_req
```

<figure><img src="https://2337193041-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FHET0AD04uHMgdeLAjptq%2Fuploads%2Flcb6UZG6eu0Vq8RTjFQd%2Fimage.png?alt=media&#x26;token=fd94d673-8aaa-4262-a412-281a155f3e05" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}

#### Reusable Mindmaps prompts for you and your team

You can create custom, standardized [.dinoprompts](https://docs.paradime.io/app-help/documentation/dino-ai/dino-prompts) for Mermaid's Mindmaps that ensure consistency across your data team. See [step-by-step guide.](https://docs.paradime.io/app-help/documentation/integrations/code-ide/mermaid-js/..#creating-mermaid-diagrams-with-.dinoprompts)
{% endhint %}

***

### Diagram Syntax Guide

#### Requirement Definition

Defines requirements with attributes like ID, text, risk, and verification method.

```mermaid
<type> user_defined_name {
    id: user_defined_id
    text: user_defined_text
    risk: <risk>
    verifymethod: <method>
}
```

**Attributes:**

* `type`: Options include `requirement`, `functionalRequirement`, `performanceRequirement`, `interfaceRequirement`, `physicalRequirement`, `designConstraint`
* `risk`: Options include `Low`, `Medium`, `High`
* `verifymethod`: Options include `Analysis`, `Inspection`, `Test`, `Demonstration`

#### Element Definition

Defines elements related to requirements, with attributes like type and document references.

```mermaid
element user_defined_name {
    type: user_defined_type
    docref: user_defined_ref
}
```

#### Relationship Syntax

Defines relationships between requirements and elements or between multiple requirements.

```mermaid
{name of source} - <type> -> {name of destination}
```

**Relationship Types:**

* `contains`
* `copies`
* `derives`
* `satisfies`
* `verifies`
* `refines`
* `traces`

### Data Team Examples

#### Single Requirement Satisfaction

```mermaid
requirementDiagram

requirement data_req {
    id: 101
    text: Ensure data quality.
    risk: high
    verifymethod: test
}

element pipeline {
    type: ETL process
}

pipeline - satisfies -> data_req
```

#### Complex Traceability

```mermaid
requirementDiagram

requirement initial_req {
    id: 201
    text: Initial data requirement.
    risk: medium
    verifymethod: inspection
}

functionalRequirement derived_req {
    id: 202
    text: Derived data functionality.
    risk: low
    verifymethod: analysis
}

element data_process {
    type: data pipeline
}

initial_req - traces -> derived_req
initial_req - satisfies -> data_process
```

### Best Practices

1. Clearly define requirement attributes (ID, text, risk level).
2. Use descriptive names for requirements and elements.
3. Limit diagram complexity by focusing on key relationships.
4. Use relationships like `traces` and `satisfies` to show dependencies and fulfillment.
5. Regularly review and update diagrams to reflect changes in project scope.

***

{% hint style="info" %}

### Additional Resources

For more syntax options and advanced features, visit the [official Mermaid documentation](https://mermaid.js.org/syntax/requirementDiagram.html).
{% endhint %}