在Alloy中更改系统内对象的服务代码

Question

我希望在对象上运行任何服务时更改对象的服务代码。 假设，每当适用于对象时，我都有一个操作，该对象的服务代码将为1，当另一个操作执行时，服务代码将为2.我想将最新的服务代码保存到每个对象。 不幸的是，我无法很好地设计我的谓词，这就是为什么从合金获得谓词不一致的消息。

我已经尝试了一些代码来为每个对象分配服务代码。 完整的代码如下所示 -

open util/ordering[Environment]

abstract sig Object{
    name: String,
    serviceCode: Int,
}{

    serviceCode >= 0 and serviceCode <= 3
}

// Events
enum Event {Event1, Event2, Event3}

abstract sig Condition{
    name: Event,
    object: Object
}


abstract sig BaseOperation{
    name: Event,
    object: Object
// it will have more attributes than Condition later
}

abstract sig Connector{
    condition:  Condition,
    baseOperation:  BaseOperation,
}


sig Environment{
    ev : set Event
}

pred execute [u:Environment, u':Environment, r:Connector] {
          some e: u.ev | {
          e = r.condition.name =>    
              u'.ev = u.ev + r.baseOperation.name
          else
              u'.ev = u.ev
      }
}

fact {
     all u:Environment-last, u':u.next, r:Connector {
         execute [u, u', r]
     }
}


sig Object1 extends Object{
}{
    name = "Object1 Object"
}

sig Object2 extends Object{
}{
    name = "Object2 Object"
}

sig Condition1 extends Condition{
}{
    name = Event1
    object = Object2
    object.serviceCode = 1
}

sig Operation1 extends BaseOperation{
}{
    name = Event2
    object = Object1
    object.serviceCode = 1
}


sig Operation2 extends BaseOperation{
}{
    name = Event3
    object = Object1
    object.serviceCode = 0
}

one sig Connector1 extends Connector{
}{
    condition = Condition1
    baseOperation = Operation1

}

one sig Connector2  extends Connector{
}{
    condition = Condition1
    baseOperation = Operation2
}

fact {
     Event3 !in first.ev &&
    Event2 !in first.ev
}

run {Event1 in last.ev} for 10

当我只有一个操作链接到一个对象时，上面的代码工作正常。 我在这里附上了图表。 只要有多个操作，合金就找不到实例。 需要帮助设计合金代码以实现我的目标。

另一种可能的方法可能是 - 而不是一个服务代码，我们可能有一个服务代码列表。 考虑时间戳以及每个服务代码。 然后在需要时找出最新的服务代码。 我们可以采用最大时间戳的服务代码。 但我不知道如何用合金设计它。

Answer 1

我想你应该看看Daniel Jackson的书。 Alloy不是具有可变赋值的编程语言。 它基本上是关系的规则引擎，可以生成一个实例 ，一组匹配这些规则的关系。 这意味着如果您需要可变分配，那么您需要一种方法来表示关系中随时间变化的可变状态。 有两种方法：

• Time - 使每个字段都有一个带有Time的列，其中Time是有序的。 我发现这非常麻烦。 Electrum项目通过提供var关键字使您更容易，然后为您维护Time列。
• Trace - 您可以将关联放置在已排序的状态 sig ，而不是将每个字段与Time相关联。 然后，该关系显示了价值随时间的变化情况。

关键问题是您的问题描述几乎与规范完全脱节。 你谈论服务然后再操作 ，它们是一样的吗？ Event和Connector在哪里？ 在您的问题描述中从未提及过它们？

让我们一个接一个：

我想更改对象的服务代码

   open util/ordering[Environment]

   sig Object {}
   enum ServiceCode { _1, _2 }

   sig Environment {
      object    : Object -> ServiceCode
   }

一般而言，您不希望将Int用于Service Code之类的东西，因为它们往往会炸毁状态空间。

Environment是我们的国家 。 我们想要为每个环境原子执行一个服务 。

......每当有任何服务在其上运作时。

   sig Service {
    serviceCode : ServiceCode
   }

   pred execute[ e, e' : Environment, o : Object, s : Service ] {
    e'.object = e.object ++ o -> s.serviceCode       
   }

假设，只要适用于Object ，我就有一个Operation ，

目前尚不清楚您对Operation的意思，我认为这是早期的服务 ？

...该对象的服务代码将为1，当另一个操作执行时， ServiceCode将为2.我想将最新的服务代码保存到每个对象。 不幸，

  pred trace {
    no first.object
    all t : Environment-last, t':t.next {
           some o: Object, s : Service {
           execute[t,t', o, s]
        }
    }
  }

  run trace

在表格视图中，这为您提供：

┌────────────────┐
│this/ServiceCode│
├────────────────┤
│_1⁰             │
├────────────────┤
│_2⁰             │
└────────────────┘

┌───────────┐
│this/Object│
├───────────┤
│Object⁰    │
├───────────┤
│Object¹    │
└───────────┘

┌────────────┬───────────┐
│this/Service│serviceCode│
├────────────┼───────────┤
│Service⁰    │_2⁰        │
├────────────┼───────────┤
│Service¹    │_2⁰        │
├────────────┼───────────┤
│Service²    │_1⁰        │
└────────────┴───────────┘

┌────────────────┬───────────┐
│this/Environment│object     │
├────────────────┼───────────┤
│Environment⁰    │           │
├────────────────┼───────┬───┤
│Environment¹    │Object¹│_2⁰│
├────────────────┼───────┼───┤
│Environment²    │Object⁰│_1⁰│
│                ├───────┼───┤
│                │Object¹│_2⁰│
└────────────────┴───────┴───┘

当你使用Alloy时，你应该做的第一件事是用简单的英语定义你想要指定的问题。 然后，您将本文中的概念转换为Alloy构造。 Alloy规范的目标是让它像散文一样。