Modelica

Core Framework

Wolfram Language API (Modern v11.3+)

(* Import and explore *)
model = SystemModel["Modelica.Electrical.Analog.Examples.ChuaCircuit"];
model["Description"]
model["Diagram"]
model["SystemEquations"]

(* Simulate *)
sim = SystemModelSimulate[model, 100];
SystemModelPlot[sim, {"C1.v", "C2.v"}]

(* Create from equations *)
CreateSystemModel["MyModel", {
  x''[t] + 2*zeta*omega*x'[t] + omega^2*x[t] == F[t]
}, t, <|
  "ParameterValues" -> {omega -> 1, zeta -> 0.1},
  "InitialValues" -> {x -> 0, x' -> 0}
|>]

(* Connect components *)
ConnectSystemModelComponents[
  {"R" ∈ "Modelica.Electrical.Analog.Basic.Resistor",
   "C" ∈ "Modelica.Electrical.Analog.Basic.Capacitor",
   "V" ∈ "Modelica.Electrical.Analog.Sources.SineVoltage"},
  {"V.p" -> "R.p", "R.n" -> "C.p", "C.n" -> "V.n"}
]

(* Linearize for control design *)
eq = FindSystemModelEquilibrium[model];
ss = SystemModelLinearize[model, eq];  (* Returns StateSpaceModel *)

Key Concepts

1. Acausal vs Causal (Chemputation Alignment)

Modelica's acausal nature means:

• Equations define relationships, not data flow
• Solver determines causality at compile time
• Same model works in multiple contexts

2. Connector Semantics (Conservation Laws)

        effort (voltage v)
Port A ──────────────────── Port B
        ←─── flow (current i) ───→

Connection equations (automatic):

• Effort variables equalized: $v_A = v_B$
• Flow variables sum to zero: $\sum i = 0$ (Kirchhoff)

3. Modelica Standard Library 4.0.0

(* Explore domains *)
SystemModels["Modelica.Electrical.*", "model"]
SystemModels["Modelica.Mechanics.Translational.*"]
SystemModels["Modelica.Thermal.HeatTransfer.*"]
SystemModels["Modelica.Fluid.*"]

Simulation API

Basic Simulation

(* Default settings *)
sim = SystemModelSimulate["Modelica.Mechanics.Rotational.Examples.CoupledClutches"];

(* Custom time range *)
sim = SystemModelSimulate[model, {0, 100}];

(* Parameter sweep (parallel execution) *)
sims = SystemModelSimulate[model, 10, <|
  "ParameterValues" -> {"R.R" -> {10, 100, 1000}}
|>];

Solver Methods

SystemModelSimulate[model, 10, Method -> "DASSL"]  (* Default, stiff DAEs *)
SystemModelSimulate[model, 10, Method -> "CVODES"] (* Non-stiff ODEs *)
SystemModelSimulate[model, 10, Method -> {"NDSolve", MaxSteps -> 10000}]

Analysis Functions

(* Find equilibrium *)
eq = FindSystemModelEquilibrium[model];
eq = FindSystemModelEquilibrium[model, {"tank.h" -> 2}];  (* Constrained *)

(* Linearize at operating point *)
ss = SystemModelLinearize[model];                     (* At equilibrium *)
ss = SystemModelLinearize[model, "InitialValues"];    (* At t=0 *)
ss = SystemModelLinearize[model, sim, "FinalValues"]; (* At end of sim *)

(* Properties from StateSpaceModel *)
Eigenvalues[ss]  (* Stability check *)
TransferFunctionModel[ss]  (* For Bode plots *)

Chemputation Patterns

Pattern 1: Chemical Reaction Network

(* A + B ⇌ C with mass action kinetics *)
CreateSystemModel["Chem.AB_C", {
  (* Conservation: total moles constant *)
  A[t] + B[t] + C[t] == A0 + B0 + C0,
  (* Rate laws *)
  A'[t] == -kf * A[t] * B[t] + kr * C[t],
  B'[t] == -kf * A[t] * B[t] + kr * C[t],
  C'[t] == +kf * A[t] * B[t] - kr * C[t]
}, t, <|
  "ParameterValues" -> {kf -> 0.1, kr -> 0.01, A0 -> 1, B0 -> 1, C0 -> 0},
  "InitialValues" -> {A -> 1, B -> 1, C -> 0}
|>]

(* Find equilibrium concentrations *)
eq = FindSystemModelEquilibrium["Chem.AB_C"];

Pattern 2: Thermodynamic Equilibration

(* Two thermal masses equilibrating *)
ConnectSystemModelComponents[
  {"m1" ∈ "Modelica.Thermal.HeatTransfer.Components.HeatCapacitor",
   "m2" ∈ "Modelica.Thermal.HeatTransfer.Components.HeatCapacitor",
   "k" ∈ "Modelica.Thermal.HeatTransfer.Components.ThermalConductor"},
  {"m1.port" -> "k.port_a", "k.port_b" -> "m2.port"},
  <|"ParameterValues" -> {
    "m1.C" -> 100, "m2.C" -> 200,  (* Heat capacities *)
    "k.G" -> 10                     (* Conductance *)
  }, "InitialValues" -> {
    "m1.T" -> 400, "m2.T" -> 300   (* Initial temperatures *)
  }|>
]

Pattern 3: Cat# Mapping

Commands

# Simulate model
just modelica-simulate "Modelica.Electrical.Analog.Examples.ChuaCircuit" 100

# Create model from equations
just modelica-create oscillator.m

# Linearize and analyze
just modelica-linearize model --equilibrium

# Parameter sweep
just modelica-sweep model --param "R.R" --values "10,100,1000"

# Export to FMU for co-simulation
just modelica-export model.fmu

Integration with GF(3) Triads

turing-chemputer (-1) ⊗ modelica (0) ⊗ crn-topology (+1) = 0 ✓  [Chemical Synthesis]
narya-proofs (-1) ⊗ modelica (0) ⊗ gay-julia (+1) = 0 ✓  [Verified Simulation]
assembly-index (-1) ⊗ modelica (0) ⊗ acsets (+1) = 0 ✓  [Molecular Complexity]
sheaf-cohomology (-1) ⊗ modelica (0) ⊗ propagators (+1) = 0 ✓  [Constraint Propagation]

Narya Bridge Type Verification

Modelica simulations produce observational bridge types verifiable by narya-proofs:

from narya_proofs import NaryaProofRunner

# Simulation trajectory as event log
events = [
    {"event_id": f"t{i}", "timestamp": t, "trit": 0, 
     "context": "modelica-sim", "content": {"state": state}}
    for i, (t, state) in enumerate(simulation_trajectory)
]

# Verify conservation
runner = NaryaProofRunner()
runner.load_events(events)
bundle = runner.run_all_verifiers()
assert bundle.overall == "VERIFIED"

SystemModel Properties

model["Description"]           (* Model description *)
model["Diagram"]               (* Graphical diagram *)
model["ModelicaString"]        (* Source code *)
model["SystemEquations"]       (* ODE/DAE equations *)
model["SystemVariables"]       (* State variables *)
model["InputVariables"]        (* Inputs *)
model["OutputVariables"]       (* Outputs *)
model["ParameterNames"]        (* Parameters *)
model["InitialValues"]         (* Default initial conditions *)
model["Components"]            (* Hierarchical structure *)
model["Connectors"]            (* Interface ports *)
model["Domain"]                (* Multi-domain usage *)
model["SimulationSettings"]    (* Default solver settings *)

Import/Export

(* Import Modelica source *)
Import["model.mo", "MO"]

(* Export model *)
Export["model.mo", SystemModel["MyModel"], "MO"]

(* Export FMU for co-simulation *)
Export["model.fmu", SystemModel["MyModel"], "FMU"]

(* Import simulation results *)
Import["results.sme", "SME"]

Org Operads Integration: Epigenetic Parameter Regulation

Overview

Modelica systems integrate with Org Operads through γ-Bridge verification, enabling agents with fixed external contracts (deterministic routing, stable interfaces) to have complete internal freedom (parameter derangement, structural rewilding).

The key insight: Parameters act as epigenetic insertion sites.

DNA sequence (agent interface) ← fixed, determines external contract
    ↓
Histone marks (parameters) ← mutable, regulate behavior
    ↓
Gene expression (observable output) ← deterministic, preserved

The 17-Moment Verification Framework

Org + Modelica Integration Pattern

using Org.Operads          # Define deterministic agent contracts
using BridgeLayer          # γ-bridge verification
using Modelica             # System dynamics simulation

# Step 1: Define Org contracts (external interface)
contract_x = define_contract(:x, :generator, Int8(1),
    Set([:request]), Set([:activity]), ...)
contract_v = define_contract(:v, :coordinator, Int8(0),
    Set([:activity]), Set([:routed]), ...)
contract_z = define_contract(:z, :validator, Int8(-1),
    Set([:routed]), Set([:constraint]), ...)

# Step 2: Create Modelica system with same structure
sys = create_aptos_triad(
    x_rate=1.0,      # Parameter 1 (epigenetic site)
    v_factor=0.8,    # Parameter 2 (epigenetic site)
    z_threshold=0.5  # Parameter 3 (epigenetic site)
)

# Step 3: Propose parameter mutation (derangement)
sys_mutant = create_aptos_triad(
    x_rate=1.2,      # Changed (derangement)
    v_factor=0.96,   # Changed (derangement)
    z_threshold=0.5  # Unchanged (still derangement)
)

# Step 4: Verify via γ-bridge (all 17 moments)
all_passed, bridge = verify_all_moments_modelica(
    contract_x,                   # Org contract (external interface)
    StructuralDiff(:aptos_triad, 1, 2, diff_data),  # Mutation specification
    sys,                          # Original system
    sys_mutant,                   # Mutated system
    20.0                          # Simulation time
)

# Step 5: Accept mutation if all moments pass
if all_passed
    println("✓ External phenotype preserved")
    println("✓ Internal parameters free to evolve")
    apply_mutation(sys, sys_mutant)
else
    println("✗ Mutation would violate contract")
end

Complete Working Example: Aptos Society 3-Agent Triad

# File: ~/.claude/skills/modelica/examples/org_aptos_dynamics.jl

using Dates
include("../../../src/bridge_layer.jl")
using .BridgeLayer

# Define Modelica system
struct ModelicaSystem
    name::Symbol
    parameters::Dict{Symbol, Float64}
    state::Dict{Symbol, Float64}
    equations::Function
    output::Function
    timestamp::DateTime
end

function create_aptos_triad(; x_rate=1.0, v_factor=0.8, z_threshold=0.5)
    parameters = Dict(:x_rate => x_rate, :v_factor => v_factor, :z_threshold => z_threshold)
    state_init = Dict(:x => 0.1, :v => 0.5, :z => 0.3)

    equations = function(state, params, t)
        x, v, z = state[:x], state[:v], state[:z]
        dx = params[:x_rate] * v - x
        dv = x - params[:v_factor] * v - z
        dz = v > params[:z_threshold] ? v : 0.1 * v
        Dict(:x => dx, :v => dv, :z => dz)
    end

    output = function(state, params)
        Dict(:activity => state[:x], :routing => state[:v], :constraint => state[:z])
    end

    ModelicaSystem(:aptos_triad, parameters, state_init, equations, output, now())
end

function simulate_system(system::ModelicaSystem, t_span; dt=0.01)
    trajectory = Dict(:time => Float64[], :x => Float64[], :v => Float64[], :z => Float64[])
    state = copy(system.state)
    t = 0.0

    while t ≤ t_span
        push!(trajectory[:time], t)
        push!(trajectory[:x], state[:x])
        push!(trajectory[:v], state[:v])
        push!(trajectory[:z], state[:z])

        derivatives = system.equations(state, system.parameters, t)
        state[:x] += dt * derivatives[:x]
        state[:v] += dt * derivatives[:v]
        state[:z] += dt * derivatives[:z]
        t += dt
    end
    trajectory
end

function extract_output(trajectory, system::ModelicaSystem)
    outputs = Dict(:activity => [], :routing => [], :constraint => [])
    for i in 1:length(trajectory[:time])
        state = Dict(:x => trajectory[:x][i], :v => trajectory[:v][i], :z => trajectory[:z][i])
        out = system.output(state, system.parameters)
        push!(outputs[:activity], out[:activity])
        push!(outputs[:routing], out[:routing])
        push!(outputs[:constraint], out[:constraint])
    end
    outputs
end

function verify_all_moments_modelica(contract, diff, sys_old, sys_new, t_span)
    # Moments 1-16: bridge verification
    bridge = construct_bridge(contract, diff)
    all_passed_1_16 = all(m.passed for m in bridge.moments[1:16])

    # Moment 17: behavioral equivalence via simulation
    traj_old = simulate_system(sys_old, t_span)
    output_old = extract_output(traj_old, sys_old)
    traj_new = simulate_system(sys_new, t_span)
    output_new = extract_output(traj_new, sys_new)

    max_diff = maximum([
        maximum(abs.(output_old[:activity] .- output_new[:activity])),
        maximum(abs.(output_old[:routing] .- output_new[:routing])),
        maximum(abs.(output_old[:constraint] .- output_new[:constraint]))
    ])

    moment_17_passed = max_diff ≤ 0.1  # 0.1 tolerance

    all_passed = all_passed_1_16 && moment_17_passed
    (all_passed, bridge)
end

# Demo: coordinated scaling preserves behavior
sys_v1 = create_aptos_triad(x_rate=1.0, v_factor=0.8, z_threshold=0.5)
sys_v2 = create_aptos_triad(x_rate=1.2, v_factor=0.96, z_threshold=0.5)

contracts = create_aptos_contracts()
diff_mutation = StructuralDiff(
    :aptos_triad, 1, 2,
    Dict(
        :is_derangement => true,
        :old_parameters => Dict(:x_rate => 1.0, :v_factor => 0.8, :z_threshold => 0.5),
        :new_parameters => Dict(:x_rate => 1.2, :v_factor => 0.96, :z_threshold => 0.5),
        :derangement_type => :coordinated_scaling,
        :preserves_equilibrium => true
    ),
    "Coordinated parameter scaling for adaptive regulation"
)

all_moments_passed, bridge = verify_all_moments_modelica(
    contracts[:x], diff_mutation, sys_v1, sys_v2, 20.0
)

if all_moments_passed
    println("✅ MUTATION ACCEPTED")
    println("✓ All 17 moments verified")
    println("✓ External behavior preserved (phenotype stable)")
    println("✓ Internal parameters free to evolve (genotype deranged)")
else
    println("❌ MUTATION REJECTED")
end

GF(3) Conservation with Org Operads

The Aptos triad maintains GF(3) balance:

1*x + 0*v + (-1)*z = 0  (∀ t)

This means:

• Agent X (+1): Generator role, activity increases
• Agent V (0): Coordinator role, routes and dampens
• Agent Z (-1): Validator role, monitors and constrains
• Total: Conserved across mutations ✓

Integration with Concomitant Skills

Related Skills

See NEIGHBOR_SKILLS.md for full connectivity map.

Core Neighbors (Concomitant)

• levin-levity (+1): Parameter exploration with optimality bounds
• levity-levin (-1): Playful validation with convergence proofs
• open-games (+1): Game-theoretic coordination
• narya-proofs (-1): Verify simulation trajectories
• langevin-dynamics (-1): Stochastic gradient flows
• fokker-planck-analyzer (+1): Equilibrium verification

Chemical Synthesis Triad

• turing-chemputer (-1): XDL synthesis → Modelica thermodynamics
• crn-topology (+1): Reaction network graph → Modelica ODEs

Lambda Calculus Bridge

• lispsyntax-acset (+1): S-expressions → ACSet → Modelica
• lambda-calculus (0): Combinators → Acausal constraints
• discopy (+1): String diagrams → Connection diagrams
• homoiconic-rewriting (-1): Lambda reduction ↔ DAE index reduction

Fixed Point Analysis

• ihara-zeta (-1): Graph spectral → Tier classification
• bifurcation (+1): Hopf detection → Phase transitions
• lyapunov-stability (-1): Stability → Newton convergence

Conservation & Constraint

• acsets (+1): Algebraic database → model structure
• propagators (+1): Constraint propagation semantics
• sheaf-cohomology (-1): Local-to-global consistency
• assembly-index (-1): Molecular complexity metrics

Scientific Skill Interleaving

This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:

Cheminformatics

• rdkit [○] via bicomodule
  • Chemical computation
• cobrapy [○] via bicomodule
  • Constraint-based metabolic modeling

Control Systems

• scikit-learn [○] via bicomodule
  • Model calibration
• scipy [○] via bicomodule
  • ODE/DAE verification

Bibliography References

• modelica: Modelica Language Specification 3.6
• wolfram: Wolfram SystemModeler Documentation
• bronstein: Geometric priors for ML

Cat# Integration

This skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:

Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826

Acausal Semantics as Bimodule

Modelica's acausal equations form a bimodule over the polynomial functor:

• Left action: Model defines constraints $F(x, y, t) = 0$
• Right action: Solver determines causality
• Bimodule law: Different causal assignments satisfy same constraints

Connector as Lens

A Modelica connector is a lens in the polynomial category:

Connector = (Effort × Flow, Effort)