The ReLang Handbook

// 1. Optional model name (stripped by the engine)
name MyModel

// 2. Global settings
paradigm    probabilistic
calibration normalize
training    laplace

// 3. Variable declarations
int   counter = 0
float rate    = 0.5
bool  flag    = false

// 4. Initial state
init start

// 5. Transitions
start ---> end : doIt (1.0)

// 6. Hyper-edges (rules)
doIt ->> doIt : selfBuff (0.8)

training                         // Laplace smoothing (default)
training laplace                 // Explicit Laplace
training aggregation arith (0.9) // Aggregation with lambda

// Minimal: no weight → defaults to 1.0, then normalised
s0 ---> s1 : go

// Explicit weight
s0 ---> s1 : go   (0.7)
s0 ---> s2 : stay (0.3)

// With named transId
s0 -t1-> s1 : myAction (0.5)

// Starts disabled (inactive until a rule enables it)
s0 ---> s1 : secret (0.5) disabled

// Self-loop
s0 ---> s0 : idle (1.0)

// Edge declared with aggregation keyword
s0 ---> s1 : boost (0.8) max

// Rule also carries its own aggregation
boost ->> otherAction : buffRule (0.9) prod

// Every time 'like' fires, it increases 'watchAgain' weight
like      ->>  watchAgain : like_boost  (0.9) max

// Every time 'skip' fires, it suppresses 'watchAgain'
skip      --!  watchAgain : skip_debuff (0.1) prod

// Rule only fires if a variable condition is met
login     ->>  premiumOffer : showOffer   (0.8) if (userTier >= 2)

// Rule that also updates a variable
purchase  ->>  upsell       : upsellRule  (0.7) if (cart > 0) then {
    revenue' := revenue + 1
}

// Short form — no explicit rule label (auto-generated)
eventA    --!  eventA       (0.05)

int   count    = 0           // integer, default 0
int   level[0..10]    = 1   // bounded integer [min..max]
float ratio    = 0.5
float prob[0.0..1.0]     = 1.0 
bool  isActive = false

// Static array
int[] scores = [10, 20, 30]

// Dynamic array (grows when you assign to index == length)
dyn int[] log = []

// Dynamic with max size
dyn int[] recent [max=5] = []   // keeps only last 5 items

// Access in an expression
x' := scores[1]          // x = 20

// Write with ArrayAssign
scores[0]' := 99         // scores becomes [99, 20, 30]

// Fire only if 'attack' has probability >= 0.6
idle ---> alert : warn if (P(attack) >= 0.6)

// Fire only if the failure probability F(action) is low
idle ---> safe  : proceed if (F(fail) < 0.1)

// Simple guard
s0 ---> s1 : step if (counter < 5)

// Compound guard
s0 ---> s2 : jump  if (flag == true AND score >= 10)

// Guard with then-block
s0 ---> s1 : advance if (n < 3) then {
    n' := n + 1
}

// Inline (no then-block needed for a single statement)
s0 ---> s1 : pay  total' := total + 10

// then-block for multiple statements
s0 ---> s1 : buy  then {
    balance' := balance - 5
    items'   := items   + 1
}

// Nested if inside then
s0 ---> s1 : check then {
    if (score > 50) then {
        grade' := 1
    }
}

print(counter)        // prints value to browser console
print(score * 2)      // expression is evaluated first

// Define a function
def clamp(x, lo, hi) {
    if (x < lo) then { return lo }
    if (x > hi) then { return hi }
    return x
}

// Use in an update
s0 ---> s1 : adjust then {
    volume' := clamp(volume + 10, 0, 100)
}

// foreach loop (works on arrays)
def sumArr(arr) {
    total' := 0
    foreach (item in arr) {
        total' := total + item
    }
    return total
}

aut RobotA {
    init idle
    idle    ---> working : start (1.0)
    working ---> idle    : stop  (1.0)
}

aut RobotB {
    init idle
    idle    ---> busy    : start (1.0)
    busy    ---> idle    : done  (1.0)
}

// Cross-module rule: RobotA's 'start' enables RobotB's 'start'
RobotA.start ->> RobotB.start : sync (0.8)

// What is the probability of eventually reaching 'Delivered'?
P=? [ F Delivered ]

// Is it almost certain we avoid 'Crashed'?
P>=0.99 [ G !Crashed ]

// Is it always the case that 'go_work' can be activated?
P=? [ F go_work_act=1 ]

// Probability of reaching success in exactly 2 steps
P=? [ X X success ]

// File: sessions.txt
buy, checkout, pay
browse, buy, browse, exit
login, buy, pay

init s0

s0 ---> s1 : a
s1 ---> s0 : b

// Every time 'a' fires it deactivates itself
a  --!  a : offA

int stock = 3
init Idle

Idle       ---> Selecting : insertCoin
Selecting  ---> Idle      : buyItem   (0.7) if (stock > 0) then {
    stock' := stock - 1
}
Selecting  ---> Idle      : cancel    (0.3)

// When stock reaches 0, buyItem disables itself
buyItem --! buyItem : outOfStock (0.1) if (stock == 0)

calibration proportional
init Feed

Feed    ---> Watch  : watch
Watch   ---> Watch  : like
Watch   ---> Feed   : dontLike
Watch   ---> Feed   : refresh   disabled
Feed    ---> List   : watchLike disabled
List    ---> Watch  : watch2

// Rules
watch     ->>  dontLike  : wd
like      --!  dontLike  : ld
like      ->>  refresh   : lr
like      ->>  watchLike : lw
dontLike  --!  watchLike : dw

calibration proportional
int  flips = 0
int  side  = 0
init toss

toss ---> toss : heads (0.5) if (flips < 10) then {
    flips' := flips + 1
    side'  := 0
}
toss ---> toss : tails (0.5) if (flips < 10) then {
    flips' := flips + 1
    side'  := 1
}

// Bias: each heads makes the next heads more likely
heads ->> heads : bias (0.9) max

init Home

Home       ---> Flying    : launch   (1.0)
Flying     ---> Delivered : success  (0.8)
Flying     ---> Crashed   : fail     (0.2)
Delivered  ---> Home      : return   (1.0)

// On failure, recovery re-enables the return path
fail ->> return (1.0)

// Useful PDL queries for this model:
// What is the probability of eventual delivery?
{ P=? [ F Delivered ] }
// Can we always recover from a crash?
[] !Crashed || <> Home

aut ArmA {
    init rest
    rest   ---> grip  : pickup (0.9)
    grip   ---> rest  : drop   (1.0)
}

aut ArmB {
    init rest
    rest   ---> place : insert  (1.0) disabled
    place  ---> rest  : release (1.0)
}

// ArmA's drop enables ArmB's insert
ArmA.drop ->> ArmB.insert : handoff (1.0)
// ArmB's release disables insert again
ArmB.release --! ArmB.insert : reset (1.0)