Giter Site home page Giter Site logo

WeakUntil Operator about rtamt HOT 4 CLOSED

BentleyJOakes avatar BentleyJOakes commented on August 13, 2024
WeakUntil Operator

from rtamt.

Comments (4)

nickovic avatar nickovic commented on August 13, 2024

You are welcome, and I apologize for the late answer, I had an important project deadline.

Thanks for the pointer to the specification patterns, I was not aware of this paper.

The short answer is yes, we can (and should) implement the weak until.

The long answer is slightly more complicated. RTAMT has been mainly targeting so far online monitoring. For online monitors, we allow only future temporal operators that are bounded in time (so that we can resolve the non-determinism by delaying the time of evaluation of the formula). Hence, for online monitors, we do not allow unbounded future temporal operators (except always and eventually, but only if they are the top operator in the formula).

On the other hand, we are planning to also support offline monitors, since all the infrastructure to do it is there. We already support them to some extent, but right now the offline monitors just call the online monitoring procedure. We want a clearer separation between the two, and a proper (more efficient) offline monitoring implementation that does not call the online procedure. This is where I see the implementation of weak until would fit.

My plan is to do this by the end of August/mid Septermber.

Your feedback is welcome.

from rtamt.

BentleyJOakes avatar BentleyJOakes commented on August 13, 2024

Thanks for your response.

First, yes I definitely see the value in separating the offline and online monitoring for specialization and efficiency. I expect to use both approaches in my work.

However, I don't see why the WeakUntil operator would not be relevant for both the online and offline monitoring approaches. Yes, as you correctly mention, it would have to be time-bounded for the online monitoring, but it is still valid semantic sugar for both approaches.

From some quick reasoning, perhaps it would simply be: A W[t1, t2] B -> Always[t1,t2](A) or A Until[t1,t2] B?

This time-bounded version should be sufficient for the use of the patterns in my (off-line) usage. I could set the time range to be the length of the trace, and this should provide the correct semantics.

from rtamt.

nickovic avatar nickovic commented on August 13, 2024

I agree and I can add the bounded weak until this week.

from rtamt.

nickovic avatar nickovic commented on August 13, 2024

The unless operator is added to the library.

from rtamt.

Related Issues (20)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.