### Complete GDS Example Setup

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/guide/pipeline.md

An example demonstrating the setup of a GDS specification including type definitions, entities, state variables, and interfaces, preparing for compilation and verification.

```python
from gds import (
    GDSSpec, BoundaryAction, Policy, Mechanism,
    compile_system, verify, project_canonical,
    typedef, space, entity, state_var, interface,
)
from gds.verification.spec_checks import (
    check_completeness, check_determinism,
    check_canonical_wellformedness,
)

# --- Step 1: Define domain ---
Temperature = typedef("Temperature", float, units="K")
Command = typedef("Command", float)

room = entity("Room", temperature=state_var(Temperature, symbol="T"))
```

--------------------------------

### Quick Start: Build Model and Run Simulation

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-analysis/README.md

Build a runnable model from a GDSSpec and run a simulation using gds-analysis and gds-sim. This example shows how to integrate custom policies and state updates, then compute trajectory distances.

```python
from gds_analysis import spec_to_model, trajectory_distances
from gds_sim import Simulation

# Build a runnable model from a GDSSpec
model = spec_to_model(
    spec,
    policies={"Sensor": sensor_fn, "Controller": controller_fn},
    sufs={"Heater": heater_fn},
    initial_state={"Room.temperature": 18.0},
)

# Run simulation
sim = Simulation(model=model, timesteps=100)
results = sim.run()

# Compute distances using StateMetric annotations
distances = trajectory_distances(spec, results.to_list())
```

--------------------------------

### Install and Run Commands

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-control/CLAUDE.md

Commands for installing dependencies and running tests using uv.

```bash
uv sync                                    # Install deps
```

```bash
uv run pytest tests/ -v                    # Run all tests
```

```bash
uv run pytest tests/test_compile.py -v     # Single test file
```

--------------------------------

### Define and Simulate an ODE Model

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-continuous/README.md

Quick start example demonstrating how to define a simple ODE model and run a simulation using gds-continuous.

```python
from gds_continuous import ODEModel, ODESimulation

# Define an ODE: dx/dt = -x
model = ODEModel(
    state_names=["x"],
    initial_state={"x": 1.0},
    rhs=lambda t, y, p: [-y[0]],
)

# Integrate
sim = ODESimulation(model=model, t_span=(0.0, 5.0))
results = sim.run()
```

--------------------------------

### Install gds-viz

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/viz/index.md

Install the gds-viz library using uv or pip.

```bash
uv add gds-viz
# or: pip install gds-viz
```

--------------------------------

### Run All Example Tests

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-examples/README.md

Execute all 168 example tests using pytest. Ensure you have the gds-examples package installed.

```bash
uv run --package gds-examples pytest packages/gds-examples -v
```

--------------------------------

### Install gds-proof

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/proof/getting-started.md

Use 'uv add' to install the gds-proof package.

```bash
uv add gds-proof
```

--------------------------------

### Install All Packages

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/CLAUDE.md

Installs all packages within the uv workspace, ensuring they are linked together.

```bash
# Install all packages (workspace-linked)
uv sync --all-packages
```

--------------------------------

### Move Examples and Notebooks to Client Repo

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/games/design/architecture-overview.md

Commands to create client directories and move example and notebook files.

```bash
# Create client repo
mkdir -p client-app/{patterns,notebooks,tests}
mv gds-games/examples/*.py client-app/patterns/
mv gds-games/notebooks/*.py client-app/notebooks/
```

--------------------------------

### Verify System with Generic Checks

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/guides/verification.md

Compile a system and then run the verification engine to get a report of findings. This example iterates through the report's findings and prints their check ID and message.

```python
from gds.verification.engine import verify

system = compile_system(name="My Model", root=pipeline)
report = verify(system)

for finding in report.findings:
    print(f"{finding.check_id}: {finding.message}")
```

--------------------------------

### Install gds-analysis

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/analysis/getting-started.md

Install the gds-analysis package using uv.

```bash
uv add gds-analysis
```

--------------------------------

### Optimizer Setup and Loop

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/psuu/guide/concepts.md

Illustrates the general interface for all optimizers, including setup, suggestion, and observation phases within a loop.

```python
optimizer.setup(space, kpi_names)
while not optimizer.is_exhausted():
    params = optimizer.suggest()
    # ... evaluate ...
    optimizer.observe(params, scores)
```

--------------------------------

### Install gds-stockflow

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/stockflow/index.md

Install the gds-stockflow package using uv or pip.

```bash
uv add gds-stockflow
# or: pip install gds-domains
```

--------------------------------

### Generate Views for All Examples

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-examples/README.md

This script iterates through multiple example directories and generates views for each. It's useful for batch processing.

```bash
for d in stockflow/sir_epidemic stockflow/sir_epidemic_dsl stockflow/lotka_volterra control/thermostat games/prisoners_dilemma games/insurance games/crosswalk; do
    uv run python packages/gds-examples/$d/generate_views.py --save
done
```

--------------------------------

### Launch Visualization Guide

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-examples/README.md

Commands to launch the interactive Marimo notebook for the visualization guide or run it as a read-only app.

```bash
# Launch the interactive marimo notebook (recommended)
uv run marimo edit packages/gds-examples/guides/visualization/notebook.py

# Run as a read-only app
uv run marimo run packages/gds-examples/guides/visualization/notebook.py
```

--------------------------------

### Run All Example Tests

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/examples/index.md

Execute all 168 tests for the example models using uv and pytest.

```bash
uv run pytest examples/ -v
```

--------------------------------

### Install gds-owl

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-owl/README.md

Install the gds-owl package. For SHACL validation support, install with the 'shacl' extra.

```bash
pip install gds-owl

# With SHACL validation support
pip install gds-owl[shacl]
```

--------------------------------

### Install All Packages (Editable)

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/README.md

Clones the gds-core repository and installs all packages in an editable, workspace-linked manner using uv.

```bash
git clone https://github.com/DynamicalSystemsGroup/gds-core.git
cd gds-core
uv sync --all-packages
```

--------------------------------

### Install gds-psuu

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/psuu/getting-started.md

Install the gds-psuu package using uv or pip. For Bayesian optimization, install with the 'bayesian' extra.

```bash
uv add gds-psuu
# or: pip install gds-analysis[psuu]
```

```bash
uv add "gds-psuu[bayesian]"
# or: pip install gds-analysis[psuu][bayesian]
```

--------------------------------

### Install gds-stockflow

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-stockflow/README.md

Install the gds-stockflow package using pip.

```bash
pip install gds-stockflow
```

--------------------------------

### Install All gds-domains Packages

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-domains/README.md

Installs the gds-domains package with all available features and dependencies.

```bash
pip install gds-domains[all]                     # everything
```

--------------------------------

### Generate Example Views

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/examples/index.md

Generate all 6 visualization views for a specific example, like the SIR epidemic model, with commentary.

```bash
uv run python examples/sir_epidemic/generate_views.py --save
```

--------------------------------

### Install gds-software

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/software/index.md

Install the gds-software package using uv or pip. This is the first step to using the software architecture DSL.

```bash
uv add gds-software
# or: pip install gds-domains
```

--------------------------------

### Install gds-domains[games] with pip

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/games/getting-started.md

Use pip to install the gds-domains package with the games extra.

```bash
pip install gds-domains[games]
```

--------------------------------

### Install gds-domains with Nashpy Package

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-domains/README.md

Installs the gds-domains package with Nash equilibrium capabilities, leveraging the nashpy library.

```bash
pip install gds-domains[nashpy]                  # + Nash equilibrium
```

--------------------------------

### Developer Workflow: Install and Test

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/design/v0.2-design.md

Commands for installing gds-framework and gds-viz in development mode, running core and viz tests, and validating a model visually using system_to_mermaid.

```bash
# Install both packages in development mode
uv sync                              # installs gds-framework
cd packages/gds-viz && uv sync       # installs gds-viz (with editable gds-framework)

# Or from repo root with workspace
uv sync --all-packages               # installs everything

# Run core tests
uv run pytest tests/ -v

# Run viz tests
uv run pytest packages/gds-viz/tests/ -v

# Validate a model visually
uv run python -c "
from examples.sir_epidemic.model import build_system
from gds_viz import system_to_mermaid
print(system_to_mermaid(build_system()))
"
```

--------------------------------

### Install GDS Framework Packages

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/guides/getting-started.md

Install the necessary GDS packages using pip. Alternatively, use uv sync if working from the monorepo.

```bash
pip install gds-framework gds-viz gds-control
```

```bash
uv sync --all-packages
```

--------------------------------

### Run Visualization Guide Tests

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-examples/README.md

Command to execute the tests for the visualization guide scripts, ensuring they produce valid Mermaid output.

```bash
# Run the visualization guide tests
uv run --package gds-examples pytest packages/gds-examples/guides/visualization/ -v
```

--------------------------------

### Build and Serve Documentation

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/CLAUDE.md

Installs documentation dependencies and builds or serves the project's documentation locally.

```bash
# Docs
uv sync --all-packages --group docs
uv run mkdocs build --strict
uv run mkdocs serve
```

--------------------------------

### Development Setup for gds-framework

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/getting-started/install.md

Clone the repository, navigate to the directory, sync dependencies with uv, and run tests.

```bash
git clone https://github.com/DynamicalSystemsGroup/gds-framework.git
cd gds-framework
uv sync
uv run pytest tests/ -v
```

--------------------------------

### Install gds-interchange

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/owl/index.md

Install the gds-interchange package. For SHACL validation support, install with the 'shacl' extra.

```bash
pip install gds-interchange
```

```bash
pip install gds-interchange[shacl]
```

--------------------------------

### Component Diagram (CP) Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/software/guide/diagram-types.md

Instantiates a ComponentModel for microservices, defining components, interfaces, and connectors between them.

```python
from gds_domains.software import (
    Component, InterfaceDef, Connector, ComponentModel,
)

model = ComponentModel(
    name="Microservices",
    components=[
        Component(name="AuthService", provides=["Auth"], requires=["UserDB"]),
        Component(name="UserStore", provides=["UserDB"]),
    ],
    interfaces=[InterfaceDef(name="Auth"), InterfaceDef(name="UserDB")],
    connectors=[
        Connector(name="Auth->Users", source="AuthService", target="UserStore", interface="UserDB"),
    ],
)
```

--------------------------------

### Minimal Complete GDS System Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-framework/CLAUDE.md

A step-by-step example demonstrating the creation of a GDS system, from defining types and state to composing blocks, compiling, and verifying the system.

```python
import gds

# 1. Define types
Temperature = gds.typedef("Temperature", float, units="celsius")
HeaterCommand = gds.typedef("HeaterCommand", float)

# 2. Define state
temp_entity = gds.entity("Room", temperature=gds.state_var(Temperature))

# 3. Define blocks
sensor = gds.BoundaryAction(
    name="Sensor",
    interface=gds.interface(forward_out=["Temperature"]),
)
controller = gds.Policy(
    name="Controller",
    interface=gds.interface(forward_in=["Temperature"], forward_out=["Heater Command"]),
)
heater = gds.Mechanism(
    name="Heater",
    interface=gds.interface(forward_in=["Heater Command"]),
    updates=[("Room", "temperature")],
)

# 4. Compose (>> auto-wires by token overlap)
system = sensor >> controller >> heater

# 5. Compile to IR
system_ir = gds.compile_system("thermostat", system)

# 6. Verify
report = gds.verify(system_ir)
assert report.errors == 0

# 7. Build spec (optional — for semantic analysis)
spec = gds.GDSSpec(name="thermostat")
spec.collect(Temperature, HeaterCommand, temp_entity, sensor, controller, heater)
canonical = gds.project_canonical(spec)  # derives h = f . g
```

--------------------------------

### Install gds-games

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-games/README.md

Install the gds-games package using pip.

```bash
pip install gds-games
```

--------------------------------

### Sweep Initialization and Run

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/psuu/guide/concepts.md

Demonstrates how to initialize a Sweep orchestrator with a model, search space, KPIs, optimizer, and run parameters, then execute the sweep.

```python
from gds_analysis.psuu import Sweep

sweep = Sweep(
    model=model,
    space=space,
    kpis=kpis,
    optimizer=optimizer,
    timesteps=100,
    runs=10,
)
results = sweep.run()
```

--------------------------------

### State Machine (SM) Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/software/guide/diagram-types.md

Instantiates a StateMachineModel for a door, defining states, events, and transitions between them.

```python
from gds_domains.software import (
    State, Event, Transition, StateMachineModel,
)

model = StateMachineModel(
    name="Door",
    states=[
        State(name="Closed", is_initial=True),
        State(name="Open"),
        State(name="Locked"),
    ],
    events=[Event(name="open"), Event(name="close"), Event(name="lock"), Event(name="unlock")],
    transitions=[
        Transition(source="Closed", target="Open", event="open"),
        Transition(source="Open", target="Closed", event="close"),
        Transition(source="Closed", target="Locked", event="lock"),
        Transition(source="Locked", target="Closed", event="unlock"),
    ],
)
```

--------------------------------

### Install GDS Interchange

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/owl/getting-started.md

Install the core gds-interchange package using pip.

```bash
pip install gds-interchange
```

--------------------------------

### Dependency Graph (DG) Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/software/guide/diagram-types.md

Shows how to create a Dependency Graph for a clean architecture system, defining modules, dependencies, and architectural layers.

```python
from gds_domains.software import (
    Module, Dep, Layer, DependencyModel,
)

model = DependencyModel(
    name="Clean Architecture",
    modules=[
        Module(name="handlers", layer="application"),
        Module(name="services", layer="domain"),
        Module(name="repository", layer="infrastructure"),
    ],
    deps=[
        Dep(source="handlers", target="services"),
        Dep(source="repository", target="services"),
    ],
    layers=[
        Layer(name="application", order=0),
        Layer(name="domain", order=1),
        Layer(name="infrastructure", order=2),
    ],
)
```

--------------------------------

### Install gds-control

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/control/index.md

Install gds-control using pip. This command adds the package to your environment.

```bash
uv add gds-control
# or: pip install gds-domains
```

--------------------------------

### Install GDS Interchange with SHACL Support

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/owl/getting-started.md

Install gds-interchange with the necessary dependencies for SHACL validation.

```bash
pip install gds-interchange[shacl]
```

--------------------------------

### Option C: Build a New DSL from Scratch

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/games/design/architecture-overview.md

Steps for building a new DSL from scratch using the gds-framework.

```markdown
1. pip install gds-framework
2. Subclass AtomicBlock for your domain
3. Build your own compiler, verification, reports
4. GDS generic checks work automatically via SystemIR projection
```

--------------------------------

### Python Live Composition Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/research/representation-gap.md

Demonstrates defining a system through live composition using Python operators and method calls.

```python
system = (sensor | observer) >> controller >> heater
system = system.feedback(wiring=[...])
```

--------------------------------

### Boolean Expression Nodes Examples

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/design/proposals/entity-redesign.md

Examples of boolean expression nodes including Comparison, Between, InSet, And, Or, and Not.

```python
Comparison("ge", left, right)
Between(expr, 0.0, 1.0)
InSet(expr, (-1, 0, 1))
And([p1, p2])
Or([p1, p2])
Not(p)
```

--------------------------------

### Verify Client App Integration

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/games/design/architecture-overview.md

Commands to initialize a client environment, add the gds-games dependency, and run a pattern example.

```bash
# In client repo
uv init && uv add gds-games
uv run python patterns/reactive_decision.py     # should work
```

--------------------------------

### Choose ODE Solvers

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/continuous/getting-started.md

Demonstrates how to select different ODE solvers for a simulation. Includes examples for stiff systems, auto-detection, and high-accuracy requirements.

```python
# Stiff system -- use an implicit solver
sim = ODESimulation(model=model, t_span=(0.0, 10.0), solver="Radau")

# Unknown stiffness -- let LSODA auto-detect
sim = ODESimulation(model=model, t_span=(0.0, 10.0), solver="LSODA")

# High accuracy -- use DOP853 with tight tolerances
sim = ODESimulation(model=model, t_span=(0.0, 10.0), solver="DOP853", rtol=1e-10, atol=1e-12)
```

--------------------------------

### Run Specific Example Test

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/examples/index.md

Execute tests for a particular example, such as the SIR epidemic model.

```bash
uv run pytest examples/sir_epidemic/ -v
```

--------------------------------

### Install gds-games with Nashpy support

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/games/equilibrium.md

Install the gds-games package with the necessary extras for Nashpy and numpy integration.

```bash
uv add "gds-games[nash]"
```

--------------------------------

### Import gds and print version

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/getting-started/install.md

After installation, import the library as 'gds' and print its version to verify the installation.

```python
import gds
print(gds.__version__)
```

--------------------------------

### SF-004: Converter Connectivity Check Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/stockflow/guide/verification.md

This example shows a warning message for a converter that is not referenced by any auxiliary.

```text
[SF-004] WARNING: Converter 'Unused Param' is not referenced by any auxiliary
```

--------------------------------

### Install gds-psuu

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-psuu/README.md

Install the gds-psuu package using uv or pip. Optional Bayesian optimization support can be included.

```bash
uv add gds-psuu
# or: pip install gds-psuu

# For Bayesian optimization (optional):
uv add "gds-psuu[bayesian]"
```

--------------------------------

### Install gds-domains with Symbolic Package

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-domains/README.md

Installs the gds-domains package with support for symbolic models, including the SymPy library.

```bash
pip install gds-domains[symbolic]                # + SymPy
```

--------------------------------

### Install gds-symbolic

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/symbolic/index.md

Install the gds-symbolic package with SymPy support. This command adds the necessary dependencies for symbolic computation.

```bash
uv add "gds-symbolic[sympy]"
```

--------------------------------

### GDS Framework Commands

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/packages/gds-framework/CLAUDE.md

Provides essential command-line instructions for managing dependencies, running tests, building the framework, and verifying the installed version.

```bash
uv sync                                    # Install dependencies
```

```bash
uv run --package gds-framework pytest packages/gds-framework/tests -v  # Run all tests
```

```bash
uv run --package gds-framework pytest packages/gds-framework/tests/test_blocks.py -v  # Single file
```

```bash
uv build --package gds-framework           # Build wheel
```

```bash
uv run python -c "import gds; print(gds.__version__)"  # Verify install
```

--------------------------------

### Initialize BayesianOptimizer

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/psuu/guide/optimizers.md

Instantiate the BayesianOptimizer with the total number of calls, the target KPI to optimize, whether to maximize or minimize, and an optional random seed. This optimizer uses a Gaussian process surrogate model to learn from past evaluations.

```python
from gds_analysis.psuu.optimizers.bayesian import BayesianOptimizer

optimizer = BayesianOptimizer(
    n_calls=30,
    target_kpi="avg_final_pop",
    maximize=True,
    seed=42,
)
```

--------------------------------

### Install gds-framework using pip

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/getting-started/install.md

Use this command to install the gds-framework package from the Python Package Index (PyPI).

```bash
pip install gds-framework
```

--------------------------------

### SF-005: Flow Completeness Check Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/stockflow/guide/verification.md

This example shows an error message when a flow has neither a source nor a target.

```text
[SF-005] ERROR: Flow 'Broken' has neither source nor target
```

--------------------------------

### Run Nash Equilibrium Analysis Notebook

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/guides/interoperability.md

Execute the interactive notebook for Nash equilibrium analysis. Ensure all packages and the 'nash' extra are synced.

```bash
uv sync --all-packages --extra nash
uv run marimo run packages/gds-examples/notebooks/nash_equilibrium.py
```

--------------------------------

### Install gds-games with uv

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/games/getting-started.md

Use uv to add the gds-games package.

```bash
uv add gds-games
```

--------------------------------

### SF-002: Flow-Stock Validity Check Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/stockflow/guide/verification.md

This example shows an error message when a flow references an undeclared stock.

```text
[SF-002] ERROR: Flow 'Transfer' references undeclared stock 'Missing'
```

--------------------------------

### SF-001: Orphan Stocks Check Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/stockflow/guide/verification.md

This example shows a warning message for an 'Orphan Stock' that has no connected flows.

```text
[SF-001] WARNING: Stock 'Unused' has no connected flows
```

--------------------------------

### Building a Custom System with Raw gds-framework

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/guides/choosing-a-dsl.md

Use the raw gds-framework to build systems directly when no existing DSL vocabulary fits your domain or when you need custom block roles. This example demonstrates composing BoundaryAction, Policy, and Mechanism blocks.

```python
from gds import (
    BoundaryAction,
    GDSSpec,
    Mechanism,
    Policy,
    compile_system,
    interface,
    verify,
)

# Build directly with the composition algebra
sensor = BoundaryAction(name="Sensor", interface=interface(forward_out=["Reading"]))
logic = Policy(name="Logic", interface=interface(forward_in=["Reading"], forward_out=["Command"]))
actuator = Mechanism(
    name="Actuator",
    interface=interface(forward_in=["Command"]),
    updates=[("Plant", "value")],
)

system = sensor >> logic >> actuator
system_ir = compile_system("Custom System", root=system)
report = verify(system_ir)
```

--------------------------------

### Numeric Expression Nodes Examples

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/design/proposals/entity-redesign.md

Examples of numeric expression nodes including FieldRef, Lit, BinOp, and UnaryOp.

```python
FieldRef("state", "temperature")
Lit(42.0)
BinOp("mul", left, right)
UnaryOp("neg", operand)
```

--------------------------------

### SC-001: Completeness Pass Example

Source: https://github.com/dynamicalsystemsgroup/gds-core/blob/dev/docs/framework/guide/verification.md

An example of a successful finding from the SC-001 check, indicating all state variables are updated.

```text
[info] SC-001: All state variables are updated by at least one mechanism
```