Towards a Rewriting Logic Semantics for Interactive Scores

Paper presented at JIM 2024

Transcript

1. Towards a Rewriting Logic Semantics for Interactive Scores Jaime Arias, Jean-Michaël Celerier, Myriam Desainte-Catherine, Carlos Olarte, Bernard P. Serpette Journées d’Informatique Musicale (JIM 2024) May 7th, 2024
2. Interactive Scores Interactive multimedia = multimedia content + interaction with the environment + spatial and temporal organization (a) Live performances (b) Museum installations (c) Plastic art installations Figure: Some examples of interactive multimedia systems. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 2/32
3. Interactive Scores The potential high complexity of these systems requires adequate specification languages for their full description and computer-assisted verification Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 3/32
4. Interactive Scores • Interactive Scores (IS) is a formalism for composing and executing interactive multimedia scenarios. • In IS, the environment has the possibility to modify, during the interpretation of the score, its temporal organization. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 4/32
5. Interactive Scores • Interactive Scores (IS) is a formalism for composing and executing interactive multimedia scenarios. • In IS, the environment has the possibility to modify, during the interpretation of the score, its temporal organization. • A score consists of: Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 4/32
6. Interactive Scores • Interactive Scores (IS) is a formalism for composing and executing interactive multimedia scenarios. • In IS, the environment has the possibility to modify, during the interpretation of the score, its temporal organization. • A score consists of: ◦ Temporal Objects (TOs): textures (multimedia processes) and structures (hierarchy). Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 4/32
7. Interactive Scores • Interactive Scores (IS) is a formalism for composing and executing interactive multimedia scenarios. • In IS, the environment has the possibility to modify, during the interpretation of the score, its temporal organization. • A score consists of: ◦ Temporal Objects (TOs): textures (multimedia processes) and structures (hierarchy). ◦ Temporal Relations: temporal (i.e. quantitative) and logical (i.e. qualitative) relations between TOs. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 4/32
8. Interactive Scores • Interactive Scores (IS) is a formalism for composing and executing interactive multimedia scenarios. • In IS, the environment has the possibility to modify, during the interpretation of the score, its temporal organization. • A score consists of: ◦ Temporal Objects (TOs): textures (multimedia processes) and structures (hierarchy). ◦ Temporal Relations: temporal (i.e. quantitative) and logical (i.e. qualitative) relations between TOs. ◦ Interaction Points: allow to change the start and stop times of TOs during execution. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 4/32
9. Interactive Scores Figure: ossia score – https://ossia.io/ Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 5/32
10. Interactive Scores • Several models have been proposed to give formal semantics: ◦ Petri nets: Desainte-Catherine et al. (2013) ◦ Process Calculi: Olarte and Rueda (2009); Toro et al. (2014) ◦ Reactive Programming: Arias et al. (2014) ◦ Linear Logic: Arias et al. (2015) ◦ Timed automata: Arias et al. (2016) Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 6/32
11. Interactive Scores • Several models have been proposed to give formal semantics: ◦ Petri nets: Desainte-Catherine et al. (2013) ◦ Process Calculi: Olarte and Rueda (2009); Toro et al. (2014) ◦ Reactive Programming: Arias et al. (2014) ◦ Linear Logic: Arias et al. (2015) ◦ Timed automata: Arias et al. (2016) However Õ: • They cannot be straightforwardly implemented or extended. • There are no practical solutions for the automatic verification. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 6/32
12. ReactiveIS ReactiveIS is a declarative programming language for the specification and interpretation of IS. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 7/32
13. ReactiveIS ReactiveIS is a declarative programming language for the specification and interpretation of IS. # hierarchical structure structure : g { name : "Group"; start-when : (wait(start(scenario),0,0) /\ wait(ev("/keyboard f"))); stop-when : wait(stop(lb), 0, INF); content : [ # light beam texture texture : lb { name : "Light Beam" ; start-when : wait(start(g),0, 1000) ; stop-when : wait(start(lb), 1184, 1184) ; msg-start : "/lightBeam on" ; msg-stop : "/lightBeam off" ; } ] ; } Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 7/32
14. ReactiveIS Some Features: • More flexible temporal organization of TOs. • Support control structures such as conditionals. • Tree-based operational semantics. • Logical semantics based on Intuitionistic Linear Logic (ILL). Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 8/32
15. ReactiveIS Some Features: • More flexible temporal organization of TOs. • Support control structures such as conditionals. • Tree-based operational semantics. • Logical semantics based on Intuitionistic Linear Logic (ILL). Some Drawbacks: • Artists would need to have knowledge of ILL to prove properties of their score. • Maybe new constructors’ behaviour may be captured in one semantic but not in the other. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 8/32
16. Our Goal Define an easily extensible executable semantics for the specification, interpretation and automatic verification of interactive scores written in ReactiveIS. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 9/32
17. Our Goal Define an easily extensible executable semantics for the specification, interpretation and automatic verification of interactive scores written in ReactiveIS. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 9/32
18. Table of contents 1. Rewriting Logic 2. A Rewrite Theory for ReactiveIS 3. Analysis of ReactiveIS Programs 4. Conclusions Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 10/32
19. 1. Rewriting Logic Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 11/32
20. Rewriting Logic • Rewriting logic (RL) is a powerful framework that can express both concurrent computation and logical deduction. • Features: ◦ Very expressive and general ◦ User-defined datatypes ◦ Large applications (e.g. biology, security, etc) ◦ Executable specification ◦ Maude system: full LTL model checking, reachability, … Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 12/32
21. Rewriting Logic In RL, the specification unit is a rewrite theory: R = equational theory Σ , E ⊎ B , R signature axioms equations rewrite rules Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 13/32
22. Rewriting Logic In RL, the specification unit is a rewrite theory: R = equational theory Σ , E ⊎ B , R signature axioms equations rewrite rules • The equational theory specifies the static behaviour. • The rewrite rules model the dynamic behaviour. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 13/32
23. Rewriting Logic sorts Note Scale . subsorts Note < Scale . --- Notes op E : -> Note [ctor] . op F : -> Note [ctor] . --- ... --- compute next half tone op half : Note -> Note . eq half(E) = F . eq half(F) = Gb . --- ... --- Compute next whole tone var N : Note . op whole : Note -> Note . eq whole(N) = half(half(N)) . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 14/32
24. Rewriting Logic sorts Note Scale . subsorts Note < Scale . --- Notes op E : -> Note [ctor] . op F : -> Note [ctor] . --- ... --- compute next half tone op half : Note -> Note . eq half(E) = F . eq half(F) = Gb . --- ... --- Compute next whole tone var N : Note . op whole : Note -> Note . eq whole(N) = half(half(N)) . Maude> red whole(D) . reduce in SCALE : whole(D) . rewrites: 3 in 0ms cpu (0ms real) (230769 rewrites/second) result Note: E Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 14/32
25. Rewriting Logic --- scale (note concatenation) var S : Scale . op _;_ : Scale Scale -> Scale [ctor] . --- Major scale : whole ; whole ; half ; whole ; whole ; whole ; half crl [major-whole] : S => S ; whole(tail(S)) if steps(S) =/= 2 /\ steps(S) =/= 6 . crl [major-half] : S => S ; half(tail(S)) if steps(S) = 2 . crl [major-half] : S => S ; half(tail(S)) if steps(S) = 6 . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 15/32
26. Rewriting Logic --- scale (note concatenation) var S : Scale . op _;_ : Scale Scale -> Scale [ctor] . --- Major scale : whole ; whole ; half ; whole ; whole ; whole ; half crl [major-whole] : S => S ; whole(tail(S)) if steps(S) =/= 2 /\ steps(S) =/= 6 . crl [major-half] : S => S ; half(tail(S)) if steps(S) = 2 . crl [major-half] : S => S ; half(tail(S)) if steps(S) = 6 . Maude> rew [7] C . rewrite [7] in SCALE : C . rewrites: 102 in 0ms cpu (0ms real) (4857142 rewrites/second) result Scale: ((((((C ; D) ; E) ; F) ; G) ; A) ; B) ; C Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 15/32
27. 2. A Rewrite Theory for ReactiveIS Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 16/32
28. A Rewrite Theory for ReactiveIS • RL allows specifying systems using an OO-like notation. • Entities are modelled as record-like structures (sort Object): O : C | a1 : v1 , . . . , an : vn object identifier (Oid) class identifier (Cid) attributes (Attribute) values Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 17/32
29. A Rewrite Theory for ReactiveIS • RL allows specifying systems using an OO-like notation. • Entities are modelled as record-like structures (sort Object): O : C | a1 : v1 , . . . , an : vn object identifier (Oid) class identifier (Cid) attributes (Attribute) values --- C Major triad op Cmajor : -> Object [ctor]. eq Cmajor = < cmajor : Chord | root: C, third: E, fifth: G > . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 17/32
30. A Rewrite Theory for ReactiveIS Syntax • Thanks to the almost zero representation distance in RL, our specification follows very closely the syntax of ReactiveIS. --- attributes for textures op start:_ : Condition -> Attribute . --- start condition op stop:_ : Condition -> Attribute . --- stop condition Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 18/32
31. A Rewrite Theory for ReactiveIS Syntax • Thanks to the almost zero representation distance in RL, our specification follows very closely the syntax of ReactiveIS. --- attributes for textures op start:_ : Condition -> Attribute . --- start condition op stop:_ : Condition -> Attribute . --- stop condition op mstart:_ : Msg -> Attribute . --- start message op mstop:_ : Msg -> Attribute . --- stop message Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 18/32
32. A Rewrite Theory for ReactiveIS Syntax • Thanks to the almost zero representation distance in RL, our specification follows very closely the syntax of ReactiveIS. --- attributes for textures op start:_ : Condition -> Attribute . --- start condition op stop:_ : Condition -> Attribute . --- stop condition op mstart:_ : Msg -> Attribute . --- start message op mstop:_ : Msg -> Attribute . --- stop message --- infinity for intervals op inf : -> Nat . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 18/32
33. A Rewrite Theory for ReactiveIS Syntax • Thanks to the almost zero representation distance in RL, our specification follows very closely the syntax of ReactiveIS. --- attributes for textures op start:_ : Condition -> Attribute . --- start condition op stop:_ : Condition -> Attribute . --- stop condition op mstart:_ : Msg -> Attribute . --- start message op mstop:_ : Msg -> Attribute . --- stop message --- infinity for intervals op inf : -> Nat . --- waiting conditions: event, lower, and upper bound op wait : WaitCondition Nat Nat -> Condition . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 18/32
34. A Rewrite Theory for ReactiveIS Syntax • Thanks to the almost zero representation distance in RL, our specification follows very closely the syntax of ReactiveIS. --- attributes for textures op start:_ : Condition -> Attribute . --- start condition op stop:_ : Condition -> Attribute . --- stop condition op mstart:_ : Msg -> Attribute . --- start message op mstop:_ : Msg -> Attribute . --- stop message --- infinity for intervals op inf : -> Nat . --- waiting conditions: event, lower, and upper bound op wait : WaitCondition Nat Nat -> Condition . --- external/internal events op event : String -> WaitCondition . --- external event Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 18/32
35. A Rewrite Theory for ReactiveIS Syntax • Thanks to the almost zero representation distance in RL, our specification follows very closely the syntax of ReactiveIS. --- attributes for textures op start:_ : Condition -> Attribute . --- start condition op stop:_ : Condition -> Attribute . --- stop condition op mstart:_ : Msg -> Attribute . --- start message op mstop:_ : Msg -> Attribute . --- stop message --- infinity for intervals op inf : -> Nat . --- waiting conditions: event, lower, and upper bound op wait : WaitCondition Nat Nat -> Condition . --- external/internal events op event : String -> WaitCondition . --- external event op start : Oid -> WaitCondition . --- TO started op stop : Oid -> WaitCondition . --- TO stopped Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 18/32
36. A Rewrite Theory for ReactiveIS Syntax --- Identifiers for temporal objects op TO : -> Cid [ctor] . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 19/32
37. A Rewrite Theory for ReactiveIS Syntax --- Identifiers for temporal objects op TO : -> Cid [ctor] . --- Variables vars O1 : Oid . vars C1 C2 : Condition . vars M1 M2 : Msg . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 19/32
38. A Rewrite Theory for ReactiveIS Syntax --- Identifiers for temporal objects op TO : -> Cid [ctor] . --- Variables vars O1 : Oid . vars C1 C2 : Condition . vars M1 M2 : Msg . --- Making TOs op make-texture : Oid Condition Condition Msg Msg -> Object . eq make-texture(O1, C1, C2, M1, M2) = < O1 : TO | start : C1, stop : C2, mstart : M1, mstop : M2 > . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 19/32
39. A Rewrite Theory for ReactiveIS Syntax --- Identifiers for temporal objects op TO : -> Cid [ctor] . --- Variables vars O1 : Oid . vars C1 C2 : Condition . vars M1 M2 : Msg . --- Making TOs op make-texture : Oid Condition Condition Msg Msg -> Object . eq make-texture(O1, C1, C2, M1, M2) = < O1 : TO | start : C1, stop : C2, mstart : M1, mstop : M2 > . --- Light Beam texture op lightBeam : -> Object . eq lightBeam = make-texture('lb, wait(start('g),0,1000), wait(start('lb),1184,1184), msg("/lightBeam on"), msg("/lightBeam off")) . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 19/32
40. A Rewrite Theory for ReactiveIS Semantics • A state of execution of a ReactiveIS program is an object of class System. op System : -> Cid --- class ID for the system --- attributes of a program's state op prog:_ : Configuration -> Attribute . op idle:_ : TOSet -> Attribute . op run:_ : TOSet -> Attribute . op done:_ : TOSet -> Attribute . op cant-start:_ : TOSet -> Attribute . op cant-stop:_ : TOSet -> Attribute . op pmsg:_ : Configuration -> Attribute . op in:_ : Configuration -> Attribute . op out:_ : Configuration -> Attribute . op time:_ : Nat -> Attribute . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 20/32
41. A Rewrite Theory for ReactiveIS Semantics Based on the tree-based semantics of ReactiveIS, we define two possible transitions: internal and observable transition. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 21/32
42. A Rewrite Theory for ReactiveIS Semantics Based on the tree-based semantics of ReactiveIS, we define two possible transitions: internal and observable transition. Internal Transition (4 rewrite rules): • It’s instantaneous: starting and stopping of TOs. • The start and stop conditions are evaluated, and the TOs’ state change, accordingly. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 21/32
43. A Rewrite Theory for ReactiveIS Semantics crl [start] : Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 22/32
44. A Rewrite Theory for ReactiveIS Semantics crl [start] : < top : System | prog: (Sys < O1 : TO | start: C1, mstart: M1, ats >), idle: (O1, SB), run: RUN, done: DONE, cant-start: NSTART, cant-stop: NSTOP, pmsg: PMSEG, in: IN, out: OUT, time: T > Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 22/32
45. A Rewrite Theory for ReactiveIS Semantics crl [start] : < top : System | prog: (Sys < O1 : TO | start: C1, mstart: M1, ats >), idle: (O1, SB), run: RUN, done: DONE, cant-start: NSTART, cant-stop: NSTOP, pmsg: PMSEG, in: IN, out: OUT, time: T > => < top : System | prog: (Sys < O1 : TO | start: C1, mstart: M1, ats >), idle: (SB, children-start(ats)), run: (O1, RUN), done: DONE, cant-start: NSTART, cant-stop: NSTOP, pmsg: (PMSEG start(O1, T)), in: IN, out: (OUT M1), time: T > Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 22/32
46. A Rewrite Theory for ReactiveIS Semantics crl [start] : < top : System | prog: (Sys < O1 : TO | start: C1, mstart: M1, ats >), idle: (O1, SB), run: RUN, done: DONE, cant-start: NSTART, cant-stop: NSTOP, pmsg: PMSEG, in: IN, out: OUT, time: T > => < top : System | prog: (Sys < O1 : TO | start: C1, mstart: M1, ats >), idle: (SB, children-start(ats)), run: (O1, RUN), done: DONE, cant-start: NSTART, cant-stop: NSTOP, pmsg: (PMSEG start(O1, T)), in: IN, out: (OUT M1), time: T > if { T ; IN ; PMSEG ; C1 } => { T ; IN ; PMSEG ; True } . Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 22/32
47. A Rewrite Theory for ReactiveIS Semantics Observable Transition (1 rewrite rule) • It represents time elapse in the system (i.e. from T to T+1). • The interaction with the environment takes place: ◦ by emitting the start and stop messages, and ◦ listening to inputs (messages) from the environment. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 23/32
48. 3. Analysis of ReactiveIS Programs Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 24/32
49. Analysis of ReactiveIS Programs • Maude’s strategy language allows us to define strategies for applying the rewriting rules in a specific order. • The parser IS2Maude automatically generates the executable RL specification of a ReactiveIS program. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 25/32
50. Analysis of ReactiveIS Programs • We can “simulate” some steps of the score by rewriting: Maude> rew [5] initState . result Object: < top : System | prog: ..., idle: ('g, 'ws), run: empty, done: 'scenario, cant-start: 'f, cant-stop: empty, pmsg: (start('scenario, 0) stop('scenario, 0)), in: none, out: none, time: 1 > Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 26/32
51. Analysis of ReactiveIS Programs • We can rewrite the initial term following a strategy to find out whether the whole scenario was successfully executed. Maude> srew [1] initState using one(step ; tick) * ; (match < top : System | done: ('scenario, TOSET'), ATS >) . Solution 1 result Object: < top : System | prog: ..., done: ('f, 'g, 'lb, 'scenario, 'wh, 'ws), ..., time: 7193 > Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 27/32
52. 4. Conclusions Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 28/32
53. Conclusions Contributions: • Executable rewriting logic semantics, implemented in Maude. • Automatic reachability analysis. • Extensible framework for new and complex constructors. • IS2Maude: ReactiveIS programs into Maude (interpreter). Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 29/32
54. Conclusions Contributions: • Executable rewriting logic semantics, implemented in Maude. • Automatic reachability analysis. • Extensible framework for new and complex constructors. • IS2Maude: ReactiveIS programs into Maude (interpreter). Future Work: • Enhance ReactiveIS with complex constructors,e.g. loops. • Symbolic real-time RL semantics (Maude and SMT solvers). • Extend analysis techniques to encompass full model-checking. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 29/32
55. Thank you for your attention! arias@lipn.univ-paris13.fr Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 30/32
56. References Jaime Arias, Myriam Desainte-Catherine, Sylvain Salvati, and Camilo Rueda. Executing Hierarchical Interactive Scores in ReactiveML. In Journées d’Informatique Musicale, JIM 2014, pages 25–34, 2014. Jaime Arias, Myriam Desainte-Catherine, Carlos Olarte, and Camilo Rueda. Foundations for reliable and flexible interactive multimedia scores. In MCM, volume 9110 of LNCS, pages 29–41. Springer, 2015. Jaime Arias, Jean-Michaël Celerier, and Myriam Desainte-Catherine. Authoring and automatic verification of interactive multimedia scores. Journal of New Music Research, 46(1):15–33, 2016. Myriam Desainte-Catherine, Antoine Allombert, and Gérard Assayag. Towards a hybrid temporal paradigm for musical composition and performance: The case of musical interpretation. Comput. Music. J., 37(2):61–72, 2013. Carlos Olarte and Camilo Rueda. A declarative language for dynamic multimedia interaction systems. In MCM, volume 38, pages 218–227. Springer Berlin Heidelberg, 2009. Mauricio Toro, Myriam Desainte-Catherine, and Camilo Rueda. Formal semantics for interactive music scores: a framework to design, specify properties and execute interactive scenarios. Journal of Mathematics and Music, 8(1):93–112, 2014. Arias et al. (JIM 2024) Towards a Rewriting Logic Semantics for Interactive Scores 31/32
57. Towards a Rewriting Logic Semantics for Interactive Scores Jaime Arias, Jean-Michaël Celerier, Myriam Desainte-Catherine, Carlos Olarte, Bernard P. Serpette Journées d’Informatique Musicale (JIM 2024) May 7th, 2024