hms/hsim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
hsim/doc/pres.typ

860 lines
23 KiB
Typst
Raw Blame History

#import "@preview/cetz:0.3.2"
#import "@preview/cetz-plot:0.1.1"
#import "@preview/finite:0.4.1"
#import "@preview/touying:0.6.1": *
#import themes.simple: *
// TODO: clarify between
// `solver.step : time * 's -> (time * (time -> 'y) * zin option) * 's`
// and `sim.step : (time * (time -> 'a)) * 's -> (time * (time -> 'b)) * 's`
#show: simple-theme.with(
aspect-ratio: "16-9",
config-common(show-bibliography-as-footnote: bibliography("sources.bib")),
)
#let cetz-canvas = touying-reducer.with(
reduce: cetz.canvas,
cover: cetz.draw.hide.with(bounds: true)
)
#let arrow(start, ..steps, stroke: black) = cetz.draw.line(
..(steps.pos().fold((start,), (acc, step) => {
let ((.., (x, y)), (d, l)) = (acc, step)
let (nx, ny) = if d == "d" {
(x, y - l)
} else if d == "u" {
(x, y + l)
} else if d == "l" {
(x - l, y)
} else if d == "r" {
(x + l, y)
} else {
(x, y)
}
acc.push((nx, ny))
acc
})),
mark: (end: "straight"),
stroke: stroke
)
#let (d, u, l, r) = ("d", "u", "l", "r")
#let box(start, dim, double: false, content: none, ..rest) = {
let (x, y) = start
let (dx, dy) = dim
cetz.draw.rect((x, y), (x + dx, y + dy), ..rest)
if double {
cetz.draw.rect((x + 0.1, y + 0.1), (x + dx - 0.1, y + dy - 0.1), ..rest)
}
if content != none {
cetz.draw.content((x + dx / 2, y + dy / 2), content)
}
}
#set raw(syntaxes: "zelus.sublime-syntax")
#show raw: set text(font: "CaskaydiaCove NF")
= Executing Hybrid Systems
Henri Saudubray
#footnote(link("https://codeberg.org/17maiga/hsim"), numbering: "*")
22/05/2025
= Hybrid Systems <touying:hidden>
== Hybrid systems, as seen in Zélus
Computation alternates between _discrete_ and _continuous_ phases.
#pause #linebreak()
Use of an ODE solver to approximate continuous behaviour.
#pause #linebreak()
Side effects and state jumps occur in discrete steps triggered by
zero-crossings.
#meanwhile
#align(horizon, {
columns(2, [
```zelus
let hybrid saw() = y where
rec der y = 1.0
init 0.0
reset z -> (0.0)
and z = up(y -. 1.0)
```
#align(center, {
import cetz: *
import cetz-plot.plot: *
canvas({
plot(
size: (9, 4), axis-style: "school-book", legend: (7.25, 4.5),
x-tick-step: 1, x-label: none, y-tick-step: 1, y-label: none,
y-grid: true, y-min: -0.5, y-max: 1.5, x-min: 0, x-max: 4.5,
plot-style: (stroke: blue), {
for i in range(5) {
add(((i, 0), (i + 1, 1)))
}
add(((0, 0),), label: [`saw`])
})
})
})
])
})
== Hybrid assertions
Assertions are themselves hybrid systems.
#pause #linebreak()
Adding assertions can change the final result, they are not _transparent_.
#pause #linebreak()
Solution: simulate assertions with their own solver.
#meanwhile
#columns(2, [
#align(horizon, [
```zelus
let hybrid saw() = y where
rec der y = 1.0
init 0.0
reset z -> (0.0)
and z = up(y -. 1.0)
and assert(0.0 <= y <= 1.0)
```
])
#colbreak()
#align(center + horizon, {
import cetz: *
canvas({
import cetz.draw: *
box((0, 0), (8, 4.5))
box((2, 0.25), (4, 1.5), content: ```zelus assert```)
box((2, 2.75), (4, 1.5), content: `...`)
arrow((-1, 3.5), (r, 3))
arrow((6, 3.5), (r, 3))
arrow((7, 3.5), (d, 1.25), (l, 6), (d, 1.25), (r, 1))
content((-1.5, 3.5), [`()`])
content((9.5, 3.5), [`y`])
content((1, 5), [`saw`])
})
})
])
= Nodes <touying:hidden>
== Discrete nodes
Nodes take an additional reset parameter `'p` for their reset function:
#align(top)[
#grid(columns: (3fr, 2fr), align: (left, left),
```ocaml
type ('p, 'a, 'b) dnode =
DNode : {
state : 's;
step : 's -> 'a -> 'b * 's;
reset : 'p -> 's -> 's;
} -> ('p, 'a, 'b) dnode
```,
cetz.canvas({
import cetz.draw: *
box((0, 0), (4, 4), content: `DNode`)
arrow((-1, 2), (r, 1))
arrow((4, 2), (r, 1))
arrow((2, 5), (d, 1))
content((-1.6, 2), `'a`)
content((5.6, 2), `'b`)
content((2, 5.6), `'p`)
}))
]
== Hybrid nodes
Hybrid nodes are a bit more complex:
#block([
```ocaml
type ('p, 'a, 'b, 'y, 'yder, 'zin, 'zout) hnode =
HNode : {
state : 's;
step : 's -> 'a -> 'b * 's;
reset : 'p -> 's -> 's;
fder : 's -> 'a -> 'y -> 'yder;
fzer : 's -> 'a -> 'y -> 'zout;
fout : 's -> 'a -> 'y -> 'b;
(* ... *)
} -> ('p, 'a, 'b, 'y, 'yder, 'zin, 'zout) hnode
```
#pause
#place(left + top, dx: 75%, dy: 36%, block(grid(
align: left + horizon, columns: (1fr, 10fr),
move(scale(y: 200%, $}$), dy: -2%), [Discrete behaviour]
), width: 40%))
#place(left + top, dx: 75%, dy: 62.5%, block(grid(
align: left + horizon, columns: (1fr, 10fr),
move(scale(y: 300%, $}$), dy: -2%), [Continuous behaviour]
), width: 40%))
])
= Solvers are nodes <touying:hidden>
== ODE solvers
#slide(repeat: 3, self => [
#let (uncover, only) = utils.methods(self)
ODE solvers are discrete nodes producing streams of functions defined on
successive intervals:
$(h: bb(R)_+) -->^D (h': bb(R)_+) times (u: [0,h'] -> bb(V))$.
#linebreak()
#grid(columns: (1fr, 1fr), align: (center, left), cetz.canvas({
import cetz.draw: *
box((0, 0), (4, 4), content: `csolver`)
arrow((-1, 2), (r, 1))
arrow((4, 3), (r, 1))
arrow((4, 1), (r, 1))
content((-1.5, 2), $h$)
content((5.5, 3), $h'$)
content((5.5, 1), $u$)
arrow((2, 5), (d, 1))
content((2, 5.6), "IVP")
}), align(horizon, cetz-canvas({
import cetz-plot.plot: *
only(1, plot(
size: (10, 4.5), axis-style: "school-book", legend: (9, 4.5),
y-tick-step: none, y-label: none, y-min: 0, y-max: 6,
x-tick-step: none, x-label: none, x-min: 0, x-max: 5,
x-ticks: ((5, $h$), (2, $h'$)), {
add(domain: (0, 2), t => calc.sin(t) + t, label: $u$)
}))
only(2, plot(
size: (10, 4.5), axis-style: "school-book", legend: (9, 4.5),
y-tick-step: none, y-label: none, y-min: 0, y-max: 6,
x-tick-step: none, x-label: none, x-min: 0, x-max: 5,
x-ticks: ((5, $h$), (2, ""), (4, $h'$)), {
add(domain: (2, 4), t => calc.sin(t) + t, label: $u$)
add(domain: (0, 2), t => calc.sin(t) + t)
}))
only(3, plot(
size: (10, 4.5), axis-style: "school-book", legend: (9, 4.5),
y-tick-step: none, y-label: none, y-min: 0, y-max: 6,
x-tick-step: none, x-label: none, x-min: 0, x-max: 5,
x-ticks: ((2, ""), (4, ""), (5, $h', h$)), {
add(domain: (4, 5), t => calc.sin(t) + t, label: $u$)
add(domain: (0, 4), t => calc.sin(t) + t)
}))
})))
])
== Zero-crossing solvers
#slide(repeat: 3, self => [
#let (uncover, only) = utils.methods(self)
Zero-crossing solvers are discrete nodes too, looking for zero-crossings on
functions:
$(h: bb(R)_+) times (u: [0, h] -> bb(V)) -->^D
(h': bb(R)_+) times (z: bb(Z)?)$.
#linebreak()
#grid(columns: (1fr, 1fr), align: (center, left), cetz.canvas({
import cetz.draw: *
box((0, 0), (4, 4), content: `zsolver`)
arrow((-1, 1), (r, 1))
arrow((-1, 3), (r, 1))
arrow((4, 1), (r, 1))
arrow((4, 3), (r, 1))
arrow((2, 5), (d, 1))
content((-1.5, 3), $h$)
content((-1.5, 1), $u$)
content((5.5, 3), $h'$)
content((5.5, 1), $z$)
content((2, 5.6), "ZC")
}), align(horizon, cetz-canvas({
import cetz-plot.plot: *
only(1, plot(
size: (10, 4.5), axis-style: "school-book", legend: (9, 4.5),
y-tick-step: none, y-label: none, y-min: -2, y-max: 5,
x-tick-step: none, x-label: none, x-min: 0, x-max: 2,
x-ticks: ((2/3, $h', h$),), {
add(domain: (0, 2/3), t => t * t - 1, label: "u")
}))
only(2, plot(
size: (10, 4.5), axis-style: "school-book", legend: (9, 4.5),
y-tick-step: none, y-label: none, y-min: -2, y-max: 5,
x-tick-step: none, x-label: none, x-min: 0, x-max: 2,
x-ticks: ((1, $h'$), (4/3, $h$)), {
add(domain: (2/3, 4/3), t => t * t - 1, label: "u")
add(domain: (0, 2/3), t => t * t - 1)
}))
only(3, plot(
size: (10, 4.5), axis-style: "school-book", legend: (9, 4.5),
y-tick-step: none, y-label: none, y-min: -2, y-max: 5,
x-tick-step: none, x-label: none, x-min: 0, x-max: 2,
x-ticks: ((2, $h', h$),), {
add(domain: (1, 2), t => t * t - 1, label: "u")
add(domain: (0, 1), t => t * t - 1)
}))
only("1, 3", cetz.draw.content((2, 4), $z = bot$))
only("2", cetz.draw.content((2, 3.9), $z != bot$))
})))
])
== A full solver
Combine an ODE solver `csolver` with a zero-crossing solver `zsolver`:
#linebreak()
#align(center, {
import cetz: *
canvas({
import cetz.draw: *
box((0, 0), (12, 4))
content((1.5, 4.5), `solver`)
box((1, 0.5), (4, 3), content: `csolver`)
box((7, 1.5), (4, 2), content: `zsolver`)
arrow((-1, 2), (r, 2))
arrow((5, 3), (r, 2))
arrow((5, 1), (r, 8))
arrow((6, 1), (u, 1), ("r", 1))
arrow((11, 2), (r, 2))
arrow((11, 3), (r, 2))
content((-1.5, 2), [$h$])
content((6, 3.5), [$h'$])
content((6, 0.5), [$u$])
content((13.5, 1), [$u$])
content((13.75, 2), [$h''$])
content((13.5, 3), [$z$])
})
})
= Signals <touying:hidden>
== Semantics
Two semantics are often used for hybrid systems:
- Superdense semantics @opsem_lee_zheng:
- signals are functions from $bb(R) times bb(N) -> bb(V)$;
- discrete instants are ordered lexicographically
- Non-standard semantics @ns_sem_benveniste_bourke_caillaud_pouzet:
- signals are functions from the hyperreals $""^*bb(R) -> bb(V)$;
- discrete instants are ordered using infinitesimals
== Optional values
The solver does not always reach the requested horizon in a single step.
#linebreak()
We _wait_ for it to finish computing:
#align(center, {
import cetz: *
canvas({
import cetz.draw: *
content((0, 1.5), "Input:")
content((0, 0), "Output:")
content((3.5, 1.5), $a_0,$)
content((3.5, 0), $bot,$)
content((5, 1.5), $bot,$)
content((5, 0), $b_0,$)
content((6.5, 1.5), $bot,$)
content((6.5, 0), $b_1,$)
content((8, 1.5), $bot,$)
content((8, 0), $b_2,$)
content((9.5, 1.5), $bot,$)
content((9.5, 0), $bot,$)
content((11, 1.5), $a_2,$)
content((11, 0), $bot,$)
content((12.5, 1.5), $bot,$)
content((12.5, 0), $b_3,$)
content((14, 1.5), $bot,$)
content((14, 0), $b_4,$)
content((15.5, 1.5), $...$)
content((15.5, 0), $...$)
})
})
This is represented by optional values:
$ "Signal"(alpha) = "Stream"("Optional"((h:bb(R)_+) times ([0,h] -> alpha))) $
== Discrete instants
Discrete instants are represented by constant functions of length 0. Their
order is the order of apparition in the stream.
== Example
The stream
#align(center, ```ocaml
f = (1.0, λt -> t)::(0.0, λt -> 2.0)::(0.3, λt -> 3*t)::...
```)
defines the function $f : ""^*bb(R)_+ -> bb(R)$
#grid(columns: (1fr, 1fr), align: (center, center), $ & f(t) = cases(
"st"(t)#footnote([
$"st"(t)$ denotes the _standard part_ of $t$, that is, the closest real
number $r$ to $t$.
]) & "if" t in [0, 1],
2 & "if" t = 1 + partial,
3 dot "st"(t) & "if" t in [1 + 2 partial, 1.3],
...
) $, cetz.canvas({
import cetz-plot.plot: *
plot(
size: (10, 3), axis-style: "school-book",
y-label: none, y-tick-step: none,
x-label: none, x-tick-step: none, x-ticks: (1, 2.3), x-grid: true,
{
add(domain: (0, 1), t => t)
add(((1, 2),), mark: "o", mark-size: 0.05,
mark-style: (stroke: blue, fill: blue))
add(domain: (1, 1.3), t => 3 * t, style: (stroke: blue))
}
)
}))
= Simulation <touying:hidden>
== Simulation
The simulation is itself a discrete node on signals:
#align(center, cetz.canvas({
import cetz.draw: *
box((0, 0), (12, 5), content: `???`)
arrow((-1, 2.5), (r, 1))
arrow((12, 2.5), (r, 1))
content((-3, 2.5), $"Signal"(alpha)$)
content((15, 2.5), $"Signal"(beta)$)
content((1, 5.5), `sim`)
box((0.5, 0.5), (4, 4), content: `model`)
box((7.5, 0.5), (4, 4), content: `solver`)
}))
It runs according to one of two modes: _discrete_ and _continuous_.
== (Re)initialization
When receiving a new value, store it
#alternatives([...], [and reset the solver.])
#align(center, cetz-canvas({
import cetz.draw: *
// sim
content((1, 6.5), `sim`)
box((0, 0), (14, 6))
// model
content((2.5, 5.25), `model`)
box((1, 1), (4, 3.75))
// model.fzer
box((1.25, 3), (3.5, 1.5), content: `fzer`)
// model.fder
box((1.25, 1.25), (3.5, 1.5), content: `fder`)
// sim state
box((10, 1.25), (3, 1.5), double: true, content: `state`)
// (h, u) -> state
content((-2.25, 3), $(h, u)$)
arrow((-1, 3), (r, 1.5), (d, 2.5), (r, 5), (u, 1.5), (r, 4.5))
// sim -> bot
arrow((14, 3), (r, 1))
content((15.5, 3), $bot$)
(pause,)
// computation
box((6, 3), (3, 1.5), content: `...`)
// solver
box((10, 3), (3, 1.5), content: `solver`)
// (h, u) -> computation
arrow((5.5, 2), (u, 1.5), (r, 0.5))
// fzer -> computation
arrow((4.75, 4), (r, 1.25))
// fder -> computation
arrow((4.75, 2), (r, 0.5), (u, 1.75), (r, 0.75))
// computation -> solver
arrow((9, 3.75), (r, 0.5), (u, 1.25), (r, 2), (d, 0.5))
content((10.5, 5.5), `ivp + zc`)
}))
== Discrete step
#alternatives(
[Use the model's `step` function and the stored input.],
[Build a constant function out of the output value.],
[Update the running mode as needed.]
)
#align(center, cetz-canvas({
import cetz.draw: *
// sim
content((1, 6.5), `sim`)
box((0, 0), (17, 6))
// sim state
box((1, 1), (3, 1.5), double: true, content: `state`)
// model
content((6.5, 5.5), `model`)
box((5, 0.5), (7, 4.5))
// model step
box((7, 1), (3, 1.5), content: `step`)
// model state
box((7, 2.75), (3, 1.5), double: true, content: `state`)
// bot -> sim
arrow((-1, 3), (r, 1))
content((-1.5, 3), $bot$)
// sim.state -> model.step
arrow((4, 1.5), (r, 3))
content((5.75, 1.25), $alpha$)
// model.state -> model.step
arrow((7, 3.5), (l, 0.5), (d, 1.5), (r, 0.5))
content((6, 2.875), $sigma$)
(pause,)
// constant signal
box((13, 1), (3, 1.5), content: `...`)
// model.step -> model.state
arrow((10, 2), (r, 0.5), (u, 1.5), (l, 0.5))
content((11, 2.875), $sigma$)
// model.step -> ...
arrow((10, 1.5), (r, 3))
content((11.25, 1), $beta$)
// constant signal -> signal(beta)
arrow((16, 1.75), (r, 0.5), (u, 1.25), (r, 1.5))
content((20, 3), $"Signal"(beta)$)
(pause,)
// computation for mode
box((1, 3.5), (3, 1.5), content: `...`)
// model.step -> mode computations
arrow((10.5, 3.5), (u, 1), (l, 6.5))
// sim.state -> mod.computations
arrow((4, 2), (r, 0.5), (u, 2), (l, 0.5))
// mod.computations -> sim.state
arrow((1, 4.25), (l, 0.5), (d, 2.5), (r, 0.5))
}))
== Continuous step
#alternatives(
[Call the solver with the current target horizon.],
[Use the current input and the result of the solver to build the output.],
[Update the model's continuous state with the new horizon.],
[Update the simulation mode in case of a zero-crossing.],
)
#align(center, cetz-canvas({
import cetz.draw: *
// sim
content((1, 6.5), `sim`)
box((0, 0), (17, 6))
// sim.state
box((1, 1), (3, 1.5), double: true, content: `state`)
// bot -> sim
arrow((-1, 3), (r, 1))
content((-1.5, 3), $bot$)
// solver
content((6.5, 5.25), `solver`)
box((5, 0.75), (6, 4))
// solver.step
box((6.5, 1), (3, 1.5), content: `step`)
// solver.state
box((6.5, 2.75), (3, 1.5), double: true, content: `state`)
// solver.state -> solver.step
arrow((6.5, 3.5), (l, 0.5), (d, 1.5), (r, 0.5))
content((5.5, 2.75), $sigma$)
// sim.state -> solver.step
arrow((4, 1.5), (r, 2.5))
(pause,)
// solver.step -> solver.state
arrow((9.5, 2.2), (r, 0.5), (u, 1.3), (l, 0.5))
// computation
box((13, 1), (3, 1.5), content: `...`)
// solver.step -> computation
arrow((9.5, 1.6), (r, 3.5))
arrow((9.5, 1.3), (r, 3.5))
// sim.state -> computation
arrow((4, 2), (r, 0.5), (d, 1.5), (r, 8), (u, 1.55), (r, 0.5))
// computation -> beta signal
arrow((16, 1.75), (r, 2.5))
content((20.5, 1.75), $"Signal"(beta)$)
(pause,)
// model
box((12.5, 2.75), (4, 2))
content((14, 5.25), `model`)
// model.state
box((13, 3), (3, 1.5), double: true, content: `state`)
// step -> model
arrow((12.25, 1.3), (u, 2.2), (r, 0.75))
arrow((12, 1.6), (u, 2.4), (r, 1))
(pause,)
// computation
box((1, 2.75), (3, 1.5), content: `...`)
// solver.step -> computation
arrow((9.5, 1.9), (r, 1), (u, 2.6), (l, 6), (d, 1), (l, 0.5))
// computation -> solver.state
arrow((1, 3.5), (l, 0.5), (d, 1.75), (r, 0.5))
}))
#pause
Is that it?
= States <touying:hidden>
== The state problem
#slide(self => [
#let (uncover, only) = utils.methods(self)
Some solvers modify their state in-place (e.g. #smallcaps("Sundials")).
#linebreak()
The function returned depends on this state.
#pause #linebreak()
It becomes invalid once we call the solver again.
#meanwhile
#align(center, cetz-canvas({
import cetz-plot.plot: *
plot(
size: (10, 4), axis-style: "school-book",
x-label: none, x-tick-step: none, x-max: 6,
y-label: none, y-tick-step: none, y-max: 6,
x-grid: true, x-ticks: ((4.5, ""),),
{
only(1, add(domain: (0, 4.5), t => calc.sin(t) + t))
only(2, add(domain: (4.5, 6), t => calc.sin(t) + t))
only(2, add(domain: (0, 4.5), t => calc.sin(t) + t))
}
)
}))
])
== Solver steps
Most solvers start off with smaller steps, and increase the step length
progressively.
#align(center, cetz.canvas({
import cetz-plot.plot: *
plot(
size: (10, 4), axis-style: "school-book", x-label: none, x-tick-step: none,
x-ticks: ((0,""), (0.001,""), (0.01,""), (0.1,""), (0.2,""), (0.4,""),
(1,""), (1.9,""), (3.9, "")), x-grid: true,
y-label: none, y-tick-step: none, {
add(domain: (0, 6), t => calc.sin(t) + t)
}
)
}))
Combined with in-place state modifications, resets and composition, this could
hinder performance.
== State copies
Copying (part of) the state solves this issue.
#linebreak()
If the solver supports state copies, we can call it more than once per
simulation step.
```ocaml
type ('p, 'a, 'b) dnode_c =
DNodeC : {
state : 's;
step : 's -> 'a -> 'b * 's;
reset : 'p -> 's -> 's;
copy : 's -> 's;
} -> ('p, 'a, 'b) dnode_c
```
== Accelerating the simulation
We can then concatenate functions obtained from successive continuous steps.
If no zero-crossing is found, there is no discontinuity.
#linebreak()
#grid(align: center + horizon, columns: (10fr, 1fr, 10fr),
cetz.canvas({
import cetz-plot.plot: *
plot(
size: (8, 4), axis-style: "school-book", x-label: none,
x-tick-step: none, x-ticks: ((3, $h_1$), (6, $h_2$)), x-grid: true,
y-label: none, y-tick-step: none, {
add(domain: (0, 3), t => calc.sin(t) + t)
add(domain: (3, 6), t => calc.sin(t) + t)
}
)
}), $==>$, cetz.canvas({
import cetz-plot.plot: *
plot(
size: (8, 4), axis-style: "school-book", x-label: none,
x-tick-step: none, x-ticks: ((6, $h_1$),), x-grid: true, y-label: none,
y-tick-step: none, { add(domain: (0, 6), t => calc.sin(t) + t) }
)
})
)
= Composing simulations <touying:hidden>
== Pushing values through
#slide(self => [
#let (uncover, only) = utils.methods(self)
Unless we can copy the state, we need to use up all of a value before
producing the next. We need to push empty values ($bot$) as needed.
#align(center, cetz-canvas({
import cetz.draw: *
box((0, 0), (3, 3), content: $M_1$)
box((8, 0), (3, 3), content: $M_2$)
only("1, 3-4", arrow((-1, 1.5), (r, 1)))
only("2, 5-", arrow((-1, 1.5), (r, 1), stroke: red))
only("1, 2, 4-", arrow((3, 1.5), (r, 5)))
only("3", arrow((3, 1.5), (r, 5), stroke: red))
only("-3", arrow((11, 1.5), (r, 1)))
only("4-", arrow((11, 1.5), (r, 1), stroke: red))
content((-3, 1.5), $"Signal"(alpha)$)
content((5.5, 2), $"Signal"(beta)$)
content((14, 1.5), $"Signal"(gamma)$)
content((-4, -1), $alpha:$)
content((-4, -2.5), $beta:$)
content((-4, -4), $gamma:$)
(pause,)
content((-2, -4), $bot$)
content((-2, -2.5), $bot$)
content((-2, -1.1), $alpha_1$)
(pause,)
content((0, -1), $bot$)
content((0, -2.6), $beta_1$)
content((0, -4), $bot$)
(pause,)
content((2, -1), $bot$)
content((2, -2.5), $bot$)
content((2, -4.1), $gamma_1$)
(pause,)
content((4, -1.1), $alpha_2$)
content((4, -2.5), $bot$)
content((4, -4.1), $gamma_2$)
content((5.5, -1), $...$)
content((5.5, -2.5), $...$)
content((5.5, -4), $...$)
(pause,)
box((3.5, -3), (1, 1), stroke: red)
box((0.1, 0.1), (2.8, 2.8), stroke: red)
content((12, -2.6), "Possible early reset!")
}))
])
== Pulling values from
#slide(self => [
#let (uncover, only) = utils.methods(self)
The output signal stops at least as often as the input signal does.
#linebreak()
This calls for a "lazy" composition: we request rather than provide data.
#align(center, cetz-canvas({
import cetz.draw: *
box((0, 0), (3, 3), content: $M_1$)
box((8, 0), (3, 3), content: $M_2$)
only("1-3, 5-10, 12-", arrow((-1, 1.5), (r, 1)))
only("4, 11", arrow((-1, 1.5), (r, 1), stroke: red))
only("1-2, 4-5, 7-8, 10-11, 13-", arrow((3, 1.5), (r, 5)))
only("3, 6, 9, 12", arrow((3, 1.5), (r, 5), stroke: red))
only("1, 3-4, 6, 9, 11-12, 14-", arrow((11, 1.5), (r, 1)))
only("2, 5, 7, 8, 10, 13", arrow((11, 1.5), (r, 1), stroke: red))
content((-3, 1.5), $"Signal"(alpha)$)
content((5.5, 2), $"Signal"(beta)$)
content((14, 1.5), $"Signal"(gamma)$)
content((-4, -1), $alpha:$)
content((-4, -2.5), $beta:$)
content((-4, -4), $gamma:$)
(pause,)
content((-2, -4), $bot$)
(pause,)
content((-2, -2.5), $bot$)
(pause,)
content((-2, -1.1), $alpha_1$)
(pause,)
content((0, -4), $bot$)
(pause,)
content((0, -2.6), $beta_1$)
(pause,)
content((2, -4.1), $gamma_1$)
(pause,)
content((4, -4.1), $gamma_2$)
(pause,)
content((6, -2.6), $beta_2$)
content((6, -4), $bot$)
(pause,)
content((8, -4.1), $gamma_3$)
(pause,)
content((10, -4), $bot$)
content((10, -2.5), $bot$)
content((10, -1.1), $alpha_2$)
(pause,)
content((12, -2.6), $beta_3$)
content((12, -4), $bot$)
(pause,)
content((14, -4.1), $gamma_4$)
(pause,)
content((15.5, -1), $...$)
content((15.5, -2.5), $...$)
content((15.5, -4), $...$)
}))
])
= Conclusion <touying:hidden>
== What next?
#align(horizon, [
- Can we avoid pointless solver resets?
- Think about assertions: is the checking of an assertion a composition?
- Plug to Zélus' output
])
Reference in a new issue View git blame Copy permalink