Multi-Level Requirement Refinement

Saphira provides comprehensive support for refining requirements through the complete development lifecycle—from high-level stakeholder needs down to detailed software and hardware specifications.

Requirement Hierarchy Levels

Stakeholder Requirements

High-level needs from users, operators, and external stakeholders:

User perspective terms (user, operator, driver)
System-level scope and context
Natural language expressions of needs
Business and operational objectives

Example: “The operator shall be able to safely stop the machine in an emergency”

System Requirements

System-level specifications that address stakeholder needs:

Technical terms and specifications
Performance criteria and constraints
System-level behavior definitions
Interface requirements between major components

Example: “The system shall achieve a maximum stopping time of 500ms from emergency stop activation”

Subsystem Requirements

Requirements allocated to specific subsystems:

Subsystem interaction specifications
Interface definitions between subsystems
Subsystem-specific performance requirements
Integration considerations

Example: “The brake subsystem shall provide a minimum braking force of 5000N within 200ms of command receipt”

Component Requirements

Detailed specifications for individual components:

Component-specific parameters
Hardware and software specifications
Detailed technical constraints
Testable acceptance criteria

Example: “The brake actuator ECU shall process brake commands within 10ms and generate PWM output at 20kHz”

Hardware (HW) Requirements

Hardware-specific implementation requirements:

Physical specifications
Electrical parameters
Environmental constraints
Manufacturing requirements

Example: “The brake actuator shall operate in temperature range -40°C to +85°C with IP67 protection”

Software (SW) Requirements

Software-specific implementation requirements:

Functional algorithms
Timing constraints
Memory requirements
Coding standards compliance

Example: “The brake control algorithm shall execute in ≤5ms per cycle and use ≤64KB RAM”

Requirement Classification

Automatic Classification

Saphira automatically analyzes requirements to suggest their appropriate level:

Classification Analysis

The system examines requirement text for:

User Perspective Terms: user, operator, driver, passenger, customer
Technical Terms: voltage, current, frequency, bandwidth, latency
System-Level Scope: system shall, the equipment, overall performance
Component Terms: ECU, sensor, actuator, module, controller
Subsystem Indicators: interface, communication, integration, connection
Hardware Terms: physical, electrical, mechanical, thermal, environmental
Software Terms: algorithm, function, code, memory, processing

Dynamic Recommendations

Based on analysis, Saphira provides recommendations:For Stakeholder Level:

Add user perspective terms
Remove technical implementation details
Broaden scope to system-level concerns

For System Level:

Add system-level scope indicators
Remove component-specific details
Add technical terms for specificity

For Component Level:

Add component-specific terms
Narrow scope to component concerns
Include measurable parameters

Requirement Decomposition Workflow

Generating Child Requirements

Step 1: Select Parent Requirement

From the Requirements table:

Select a requirement to decompose
Click Generate Children or use the ”+” decomposition action
Choose decomposition type:
- Functional Decomposition: Break down by functions
- Architectural Decomposition: Break down by components
- Safety Decomposition: Break down by safety aspects

Step 2: AI-Assisted Generation

Saphira generates child requirements following INCOSE principles:

Atomicity: Each requirement specifies exactly ONE capability
Verifiability: Each requirement is testable through a single procedure
Clarity: Precise language, avoiding vague terms
Traceability: Automatic parent-child linking

Generated requirements use “shall” statements and follow the pattern: “The [system/component] shall [action/constraint] [value] [unit] [condition]”

Step 3: Review and Refine

Review generated requirements:

Edit text inline for clarification
Adjust classification level if needed
Add additional constraints or conditions
Verify traceability links are correct
Save to project database

Elevating to Parent Requirements

For bottom-up consolidation:

Select lower-level requirements
Choose Elevate to Parent
Saphira generates a higher-level requirement that encompasses selected children
Review and adjust the parent requirement
Traceability links are automatically created

For automotive projects following ISO 26262, Saphira supports the complete safety concept hierarchy:

Hazard → Safety Goal

From HARA hazards, generate Safety Goals:

One Safety Goal per unique hazardous event
Atomic statements (no “or”/“and” alternatives)
ASIL inheritance from hazards
Clear safety objectives

Safety Goal → Functional Safety Requirement (FSR)

From Safety Goals, generate FSRs:

High-level “System shall…” statements
Technology-agnostic language
Functional behavior focus
INCOSE-compliant writing

FSR → Technical Safety Requirement (TSR)

From FSRs, generate detailed TSRs:

Hardware requirements
Software requirements
Interface specifications
Timing constraints
Diagnostic coverage requirements

TSR → Safety Mechanism (SM)

Technical implementation of safety functions:

Fault detection methods
Safe state specifications
Diagnostic coverage levels
Response time requirements

INCOSE Requirements Engineering

All generated requirements follow INCOSE best practices:

Requirement Quality Rules

Principle	Description	Example
Atomicity	One capability per requirement	✅ “System shall detect obstacles”
Verifiability	Testable with single procedure	✅ “Response time shall be ≤100ms”
Clarity	No ambiguous terms	❌ Avoid “appropriate”, “adequate”
Single Safe State	One safe state per requirement	✅ “System shall enter safe state A”
Shall Statements	Active voice with “shall”	✅ “The system shall provide…”

INCOSE Linting

Saphira provides automated requirement quality checking:

Input: Enter or import requirement text
Classify: Auto-suggest appropriate level
INCOSE Lint: Quality check against rules
Trace: Link to related artifacts
Export: Generate compliant documentation

Traceability Management

Automatic Trace Suggestions

When creating requirements, Saphira suggests traces to:

Related safety analyses (FMEA failure modes, HARA hazards)
Existing requirements at adjacent levels
Test cases and verification activities
Standards clauses

Traceability Matrix

View and manage requirement relationships:

Parent-child decomposition trees
Cross-level traceability
Verification coverage analysis
Gap identification for missing traces

Integration with VAS Workflows

Refined requirements integrate with:

FMEA: Requirements become focus elements for failure mode analysis
HARA: Requirements trace to hazards and control measures
Test Generation: Requirements drive test case creation
Safety Case: Requirements provide evidence for GSN goals
Gap Analysis: Requirements map to standards clauses

Get Started

Extraction & Requirements

Safety Analysis

Verification & Compliance

Safety Case & Standards

Multi-Level Requirement Refinement