{"_id": "ov9DfaEBdzo9PThyg", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "kMMBBZmMDwhWLezFw", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-9 04:28:22"}
{"_id": "FemRTPXBSRSvanEL9", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 09:57:58"}
{"_id": "giMSZrX2X6mpuTGC4", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "rtorT6dhjjcFTEuoT", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-22 11:02:32"}
{"_id": "63gDq3Gxdgd2pEMkp", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Component.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "quEsaoLZ2Nyg4zcS4", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 20:25:04"}
{"_id": "5q3azcXDjqeesaHtX", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tno (Component.^parts).Component\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "L5jj3wKuncFNzbTRr", "msg": "This cannot be a legal relational join where\nleft hand side is this/Component . ^ (this/Component <: parts) (type = {this/Product})\nright hand side is this/Component (type = {this/Component})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:51:38"}
{"_id": "WGWRLPc3amRToACaP", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \t\n  \tall c:Component | c.parts.position not in c.position.^next\n}", "derivationOf": "E5saYuEgsKLJn9BLi", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 19:44:18"}
{"_id": "PBdH76wPWvs7fCA4S", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c->c in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "DjxA3Bmec2PcYXi4m", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:47:45"}
{"_id": "99DJkdMHZ2aXTPn55", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "s7XgGfhSsbQWtGjat", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:03:16"}
{"_id": "oTMBWD5DngKcHjW28", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "w6AGwcMQzPY36GYcA", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 19:41:33"}
{"_id": "64CJuefBsCnW6Xkua", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n  \tall c:Component | c.parts.position in c.position.~next\n}", "derivationOf": "jTj8h6rvWsgM8Q97a", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 19:47:16"}
{"_id": "ko4YZD2uc9ygeaM5E", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "kJz4gZ4ZTtmystgHj", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 15:07:45"}
{"_id": "yjtP33rCz5xKaABSy", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some s.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "msg": "The name \"s\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-7 19:26:31"}
{"_id": "dxTzNkE4zAZmtCXox", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Component | all p : c.parts | some pos : c.position.prevs | p.position = pos", "derivationOf": "nwutMh3PGNcpvkriH", "msg": "There are 38 possible tokens that can appear here:\n! # ( * @ Int NAME NUMBER STRING String Time ^ after all always before disj eventually fun historically iden int let lone no none once one pred seq set some sum this univ { } ~", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-7 19:41:42"}
{"_id": "tBPGBfgHCG4urYjEB", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Component.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 15:06:25"}
{"_id": "TzRcf27oyqFX5ad3X", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component.position | some Robot.position in c\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "kG6tJJCywwK2QKbkM", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:06:25"}
{"_id": "3v2Jju2DATpi8ysYr", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.^parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position = Robot.position \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "YTd3Bp5GHRC4vwo2K", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 11:04:43"}
{"_id": "qigwXZtriNfcmSNkQ", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Component | all p : c.parts | some pos : c.position.prevs | p.position = pos\n\n}", "derivationOf": "hG9Scf2YKSuBFHh5C", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-7 19:42:17"}
{"_id": "5E3zzryz5AMwKTCue", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "AT2d6FWXQJDXwN9Fs", "original": "jyS8Bmceejj9pLbTW", "theme": {"currentFramePosition": {}, "currentlyProjectedSigs": [], "generalSettings": {"currentLayout": "breadthfirst", "metaPrimSigs": [{"parent": null, "type": "univ"}, {"parent": "Product", "type": "Component"}, {"parent": "univ", "type": "Int"}, {"parent": "univ", "type": "Position"}, {"parent": "univ", "type": "Product"}, {"parent": "univ", "type": "RejectedBy"}, {"parent": "Product", "type": "Resource"}, {"parent": "univ", "type": "Robot"}, {"parent": "RejectedBy", "type": "ShouldBeAccepted"}, {"parent": "RejectedBy", "type": "ShouldBeRejected"}, {"parent": "univ", "type": "String"}, {"parent": "null", "type": "univ"}, {"parent": "univ", "type": "ordering/Ord"}, {"parent": "Int", "type": "seq/Int"}, {"parent": "Product", "type": "Component"}, {"parent": "univ", "type": "Int"}, {"parent": "univ", "type": "Position"}, {"parent": "univ", "type": "Product"}, {"parent": "univ", "type": "RejectedBy"}, {"parent": "Product", "type": "Resource"}, {"parent": "univ", "type": "Robot"}, {"parent": "RejectedBy", "type": "ShouldBeAccepted"}, {"parent": "RejectedBy", "type": "ShouldBeRejected"}, {"parent": "univ", "type": "String"}, {"parent": "null", "type": "univ"}, {"parent": "univ", "type": "ordering/Ord"}, {"parent": "Int", "type": "seq/Int"}], "metaSubsetSigs": []}, "nodePositions": {"Component": {"x": 761.1428571428571, "y": 132.66666666666666}, "Position0": {"x": 126.85714285714283, "y": 132.66666666666666}, "Position1": {"x": 296, "y": 265.3333333333333}, "Position2": {"x": 634.2857142857142, "y": 132.66666666666666}, "Product": {"x": 507.42857142857144, "y": 132.66666666666666}, "Resource": {"x": 592, "y": 265.3333333333333}, "Robot": {"x": 380.57142857142856, "y": 132.66666666666666}, "ShouldBeAccepted": {"x": 253.71428571428572, "y": 132.66666666666666}, "ordering/Ord": {"x": 444, "y": 132.66666666666666}}, "relationSettings": {"edgeColors": [{"color": "#0074D9", "relation": "First"}, {"color": "#0074D9", "relation": "Next"}, {"color": "#0074D9", "relation": "parts"}, {"color": "#0074D9", "relation": "position"}], "edgeStyles": [{"edgeStyle": "solid", "relation": "First"}, {"edgeStyle": "solid", "relation": "Next"}, {"edgeStyle": "solid", "relation": "parts"}, {"edgeStyle": "solid", "relation": "position"}], "showAsArcs": [{"relation": "general", "showAsArcs": true}, {"relation": "First", "showAsArcs": true}, {"relation": "Next", "showAsArcs": true}, {"relation": "parts", "showAsArcs": true}, {"relation": "position", "showAsArcs": true}, {"relation": "ShouldBeRejected", "showAsArcs": true}, {"relation": "ShouldBeAccepted", "showAsArcs": true}, {"relation": "ordering/Ord", "showAsArcs": true}, {"relation": "Position", "showAsArcs": true}, {"relation": "Robot", "showAsArcs": true}, {"relation": "Product", "showAsArcs": true}, {"relation": "Component", "showAsArcs": true}, {"relation": "Resource", "showAsArcs": true}], "showAsAttributes": [{"relation": "position", "showAsAttributes": false}, {"relation": "parts", "showAsAttributes": false}, {"relation": "First", "showAsAttributes": false}, {"relation": "Next", "showAsAttributes": false}]}, "sigSettings": {"nodeBorders": [{"border": "solid", "type": "univ"}, {"border": "inherit", "type": "Component"}, {"border": "inherit", "type": "Product"}, {"border": "inherit", "type": "Int"}, {"border": "inherit", "type": "Position"}, {"border": "inherit", "type": "Resource"}, {"border": "inherit", "type": "Robot"}, {"border": "inherit", "type": "ShouldBeRejected"}, {"border": "inherit", "type": "RejectedBy"}, {"border": "inherit", "type": "ordering/Ord"}, {"border": "inherit", "type": "seq/Int"}, {"border": "inherit", "type": "ShouldBeAccepted"}, {"border": "inherit", "type": "general"}], "nodeColors": [{"color": "#2ECC40", "type": "univ"}, {"color": "#01FF70", "type": "Component"}, {"color": "#FFDC00", "type": "Product"}, {"color": "inherit", "type": "Int"}, {"color": "#39CCCC", "type": "Position"}, {"color": "#3D9970", "type": "Resource"}, {"color": "#85144b", "type": "Robot"}, {"color": "#FF4136", "type": "ShouldBeRejected"}, {"color": "inherit", "type": "RejectedBy"}, {"color": "inherit", "type": "ordering/Ord"}, {"color": "inherit", "type": "seq/Int"}, {"color": "#FF4136", "type": "ShouldBeAccepted"}, {"color": "inherit", "type": "general"}], "nodeShapes": [{"shape": "ellipse", "type": "univ"}, {"shape": "inherit", "type": "Component"}, {"shape": "inherit", "type": "Product"}, {"shape": "inherit", "type": "Int"}, {"shape": "rectangle", "type": "Position"}, {"shape": "inherit", "type": "Resource"}, {"shape": "hexagon", "type": "Robot"}, {"shape": "octagon", "type": "ShouldBeRejected"}, {"shape": "inherit", "type": "RejectedBy"}, {"shape": "inherit", "type": "ordering/Ord"}, {"shape": "inherit", "type": "seq/Int"}, {"shape": "octagon", "type": "ShouldBeAccepted"}, {"shape": "inherit", "type": "general"}], "nodeVisibility": [{"type": "univ", "visibility": false}, {"type": "Int", "visibility": true}, {"type": "seq/Int", "visibility": true}, {"type": "general", "visibility": false}, {"type": "Component", "visibility": false}, {"type": "Position", "visibility": false}, {"type": "Resource", "visibility": false}, {"type": "Robot", "visibility": false}, {"type": "ShouldBeRejected", "visibility": false}, {"type": "ordering/Ord", "visibility": true}, {"type": "Product", "visibility": false}, {"type": "ShouldBeAccepted", "visibility": false}]}}, "time": "2019-11-10 22:49:47"}
{"_id": "g483cTWFyfLtC2mPb", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts:>(c.position.~^next)\n}", "derivationOf": "rq3dHn4G42LQk4h9m", "msg": "This must be a formula expression.\nInstead, it has the following possible type(s):\n{none}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:14:07"}
{"_id": "HJzNwiesNXnwX5FAQ", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n   \tall c:Component | some c->p:Product in parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "JTKgjtbFPjHSXv4BF", "msg": "There are 38 possible tokens that can appear here:\n! # ( * @ Int NAME NUMBER STRING String Time ^ after all always before disj eventually fun historically iden int let lone no none once one pred seq set some sum this univ { } ~", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 00:41:17"}
{"_id": "ZZ8WhaRk6SH9ZMjbE", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | some c.p implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "8u3jki6mFc5QwTwX6", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:41:34"}
{"_id": "zHxsHSNvgPcqnK6Ao", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c->c in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "PBdH76wPWvs7fCA4S", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:47:49"}
{"_id": "uuhSQpZSyqgmJq8uj", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(c.parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "mzGW5wvwimXczjpkx", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is c . (this/Component <: parts) (type = {this/Product})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:30:40"}
{"_id": "yMxiATrfELowQRAJ7", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.^parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "6wTbqmTTywQ8wBwSM", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-22 11:05:32"}
{"_id": "EYRbhPnvoDmzvXgHw", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n\n    all c:Component | c.parts.position in c.position.*prev \n\n}", "derivationOf": "LdkYj5XYu35Dsf5yj", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 16:54:06"}
{"_id": "93XedNo8gYkR9MGr6", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | c.parts not in c.^~next\n}", "derivationOf": "qEwGEKkFTKA7hMApv", "msg": "This name is ambiguous due to multiple matches:\nfun integer/next\nfun ordering/next", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:09:20"}
{"_id": "PK6AhRiBjvfANtR6q", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "udoCacj6fY4uFcbSy", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 09:53:24"}
{"_id": "c4DjWbiXdgM2rwjwa", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.^parts) & Component).position not in (c.position).^next\n}", "derivationOf": "skyb8D22nN8Q9L8Bg", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:13:38"}
{"_id": "Em9f77XBiCboJKNaT", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | no (c.parts & c.position.~^next) \n}", "derivationOf": "xJj83T8obqsCs6mRf", "msg": "& is irrelevant because the two subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:47:20"}
{"_id": "AJTfHSAm4baXeeWTW", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | no (c.parts & c.parts.position.~^next)\n}", "derivationOf": "Em9f77XBiCboJKNaT", "msg": "& is irrelevant because the two subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:48:25"}
{"_id": "5AiC2meFP47w7XtKL", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | (c.parts) in (c.parts - c) \n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "Ygoe9umJ8H4K3D7h8", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-9 04:34:07"}
{"_id": "4F4AR3qdxnKbCyYYB", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Component | all p : c.parts | some pos : c.position.prevs | p.position = pos", "derivationOf": "dxTzNkE4zAZmtCXox", "msg": "There are 38 possible tokens that can appear here:\n! # ( * @ Int NAME NUMBER STRING String Time ^ after all always before disj eventually fun historically iden int let lone no none once one pred seq set some sum this univ { } ~", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-7 19:41:57"}
{"_id": "RgqFxoAvf4EXmf4i6", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n  \n  \n  all c:Component | c.^parts.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "LcaEDj4GKagyLXJEc", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-11-10 23:14:28"}
{"_id": "t4MY45FWpt7KMR2pJ", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Component | all p : c.parts | not (some pos: c.position.^next | p.position = pos)\n\n}", "derivationOf": "qigwXZtriNfcmSNkQ", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-7 19:44:23"}
{"_id": "PFJgZTTRRLNeEubq5", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.^parts) & Component).position not in (c.position).*next\n}", "derivationOf": "c4DjWbiXdgM2rwjwa", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:56:25"}
{"_id": "eEWHQFwfAmfqNXbL7", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "TFg8MXgdQNavBTp4b", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:04:24"}
{"_id": "zwWjzde3mBJEEdPyv", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->parts->c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | some c.p implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "uJDkG4ft6x89r6b66", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:41:12"}
{"_id": "PPe4TE573KE54Wsk5", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ibpDZBbZwydDmB7j2", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 09:55:56"}
{"_id": "JTKgjtbFPjHSXv4BF", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some p:Product | some c->p in parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "7gopAbFbXPsRfmtqo", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 00:39:55"}
{"_id": "Ygoe9umJ8H4K3D7h8", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "pTR85nLB3Wcacb5v9", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-9 04:32:44"}
{"_id": "auxMRuFAhoeZ3KAGf", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c.parts in iden\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "xMmYtBFgcsQCT6Bop", "msg": "in can be used only between 2 expressions of the same arity.\nLeft type = {this/Product}\nRight type = {univ->univ}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:32:08"}
{"_id": "skyb8D22nN8Q9L8Bg", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.parts) & Component).position not in (c.position).^next\n}", "derivationOf": "EC3zcrhrCwhiSzDS2", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:13:12"}
{"_id": "weznZKimxAAeN26FC", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "oGLJZyRtX7aCdtuc5", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-7 19:27:14"}
{"_id": "ynKmmMumr9gRaswKa", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "weznZKimxAAeN26FC", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-7 19:27:18"}
{"_id": "LcaEDj4GKagyLXJEc", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n  \n  \n  all c:Component | c.parts.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "fiZQ9Zc7D2c6qRtze", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-11-10 23:13:51"}
{"_id": "ef4gWiJqbsax2SC23", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Component<:parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "63gDq3Gxdgd2pEMkp", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 20:25:11"}
{"_id": "JSrAcQgSMfcif9HKB", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Component.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 09:54:52"}
{"_id": "B33RNomyZtmQS2Y2m", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | r.component = c.component\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "Gd9oYvfX8JirfXmE4", "msg": "The name \"component\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:08:03"}
{"_id": "Mi9yybKFMHRXo89pE", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(parts.c)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "NegLr9xynWhzWgdeP", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is (this/Component <: parts) . c (type = {this/Component})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:36:12"}
{"_id": "udoCacj6fY4uFcbSy", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 09:52:48"}
{"_id": "TnkSogb4zJiafshQz", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | p in Component implies c.position in p.position.nexts \n}", "derivationOf": "8nqxyypbuXAtoagmd", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:50:52"}
{"_id": "X4j93xkLtMSYgaHtM", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Components | all p : c.parts | p in c.position.prevs.parts\n}", "derivationOf": "KKkZDpk3pCcxcWjh8", "msg": "The name \"Components\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-7 19:35:58"}
{"_id": "AutqvKkgk5p9eqpZ5", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Coponent | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "msg": "The name \"Coponent\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-11-10 22:18:58"}
{"_id": "oz2Dufom2t9MLQRBh", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c.^parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    Robot.position in Component.position \n}", "derivationOf": "uZN9EDqg3nq2CcrFQ", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:56:06"}
{"_id": "pgfnSZwRpsryCyTGB", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "x45tuPxpMLGzgaWL5", "msg": "This variable is unused.", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 11:01:34"}
{"_id": "bKKzD54p6nyYCPkNt", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | c.position < c.prevs.position\n}", "derivationOf": "iHnc3Yk4eFFdXiWWS", "msg": "This must be an integer expression.\nInstead, it has the following possible type(s):\n{this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:44:07"}
{"_id": "KKkZDpk3pCcxcWjh8", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ynKmmMumr9gRaswKa", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-7 19:28:20"}
{"_id": "GaGNnbH2sAGznx9dg", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in c.position.~^next\n}", "derivationOf": "Ee4N65Xv3Y9oFTqBw", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:10:09"}
{"_id": "RDu5yptBvFjjmWQMm", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "m48gdH4qKs3ENQL6h", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:56:46"}
{"_id": "PKmm8wrYmCLM9Jt2b", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c.^parts & c not in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "eWYd5KydoLHvGZXJh", "msg": "!in can be used only between 2 expressions of the same arity.\nLeft type = {this/Component}\nRight type = {this/Component->this/Product}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:49:57"}
{"_id": "m48gdH4qKs3ENQL6h", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "JBpN4TeY5S5yYCskt", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:56:44"}
{"_id": "zeTNT8LdckiqftdAE", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "AXRxg74uLevXqYE8h", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 19:41:40"}
{"_id": "s7XgGfhSsbQWtGjat", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | some (c.position).~position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "P9Z3WxurmjqoBx5xg", "msg": "This name is ambiguous due to multiple matches:\nfield this/Component <: position\nfield this/Robot <: position", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:02:32"}
{"_id": "g7jDjLDkRc9GhRdH5", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in c.position.~^next\n}", "derivationOf": "Ec5Yr5FvSoXv8JLfM", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:11:38"}
{"_id": "e8HfMFaC4hcXNsz5K", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(c<:parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "h6hqZcBZrbjwxLR2M", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:33:16"}
{"_id": "gAMFjdjyJpz5oGHxN", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n  \tall c:Component | c.parts.position in c.position.*prev\n}", "derivationOf": "64CJuefBsCnW6Xkua", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 19:48:00"}
{"_id": "F6mPCaohJWW5zjjGf", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | (c.parts).position in (c.position).^~next\n}", "derivationOf": "nzDHZMhwjiDWTevva", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:10:21"}
{"_id": "uZN9EDqg3nq2CcrFQ", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c.^parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "n9nkEiwZSXNqXcsLG", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:53:35"}
{"_id": "6wTbqmTTywQ8wBwSM", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.^parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component, r:Robot | c.position = r.position \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "3v2Jju2DATpi8ysYr", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 11:05:07"}
{"_id": "SrWEeBTd66nAxjSaC", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | all p:(c.position) | some r:Robot | r.position in p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "FZ7nkzqEqGC4PrxpR", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-9 04:45:02"}
{"_id": "7gopAbFbXPsRfmtqo", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some p:Product | some c->p in parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 00:38:35"}
{"_id": "FZ7nkzqEqGC4PrxpR", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "yrEa4shyBtRWwsPE9", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-9 04:41:00"}
{"_id": "S3FXrwFG55THu37DA", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "K3qHfbt6i729gQbXM", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 15:08:06"}
{"_id": "6eyKCT7wehDbdbaGj", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "njFA9mHMqqeB3w6Th", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:43:33"}
{"_id": "WB5JgCr5v24TZnKED", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | p in Component implies c.position in p.position.*next \n}", "derivationOf": "TnkSogb4zJiafshQz", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 16:51:55"}
{"_id": "oiAAQXWfwDgqFfuoQ", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "giMSZrX2X6mpuTGC4", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 11:02:35"}
{"_id": "nwutMh3PGNcpvkriH", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Component | all p : c.parts | p in c.position.prevs.parts\n}", "derivationOf": "X4j93xkLtMSYgaHtM", "msg": "The join operation here always yields an empty set.\nLeft type = {this/Position}\nRight type = {this/Component->this/Product}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-7 19:36:03"}
{"_id": "3rfpY59xJk44TFjpk", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "w6AGwcMQzPY36GYcA", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 22:34:23"}
{"_id": "t67WRB3GW7wnc3cSb", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.parts in c.position.~^next\n}", "derivationOf": "hzKMq8w7PzCuM5MrB", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:54:50"}
{"_id": "fNDB44G9u9nxxR4mA", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n  \tall c:Component | c.parts.position in c.^~position\n}", "derivationOf": "WGWRLPc3amRToACaP", "msg": "This name is ambiguous due to multiple matches:\nfield this/Component <: position\nfield this/Robot <: position", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 19:45:56"}
{"_id": "oGLJZyRtX7aCdtuc5", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "yjtP33rCz5xKaABSy", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-7 19:26:36"}
{"_id": "nzDHZMhwjiDWTevva", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | (c.parts).position not in (c.position).^~next\n}", "derivationOf": "WnBXGzka33YPTeBS4", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:10:12"}
{"_id": "Ee4N65Xv3Y9oFTqBw", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in c.position.~^next\n}", "derivationOf": "QjnWNw3A9pCEyHWj7", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:10:02"}
{"_id": "kMMBBZmMDwhWLezFw", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Component.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-9 04:27:27"}
{"_id": "DSPospR2YPFRwFSur", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "GDmbKBwtp7ppGBtiW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:46:47"}
{"_id": "P7Tc3dowxG7YTi4a5", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(c<:parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "uuhSQpZSyqgmJq8uj", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:30:50"}
{"_id": "AT2d6FWXQJDXwN9Fs", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "cepGWJQq4FXCqaPok", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-11-10 22:20:00"}
{"_id": "s7DF344fNmo9nvbfe", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tno (Component<:*parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "xDztjhzkNEy6RCnis", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:52:22"}
{"_id": "HfyHmaaZLMMoREbtN", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->parts->c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | some c.p implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "zwWjzde3mBJEEdPyv", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:41:17"}
{"_id": "ioGJNuZdfj6QotH6E", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.^parts) & Component).position not in (c.position).^next or no (c.^parts & Component)\n}", "derivationOf": "HXXfLY88SuaGxwiCQ", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:59:23"}
{"_id": "eWYd5KydoLHvGZXJh", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c & ^parts<:c not in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "AxMFjo4i4RqePHpWh", "msg": "This must be a unary set, but instead it has the following possible type(s):\n{this/Component->this/Product}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:49:42"}
{"_id": "AXRxg74uLevXqYE8h", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "oTMBWD5DngKcHjW28", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 19:41:37"}
{"_id": "pnbSywBb2egSDGABa", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | r.Component = c.Component\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "B33RNomyZtmQS2Y2m", "msg": "This cannot be a legal relational join where\nleft hand side is r (type = {this/Robot})\nright hand side is this/Component (type = {this/Component})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:08:15"}
{"_id": "xwvrQQApH4pTZ5RdB", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component, r:Robot | c.position in r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "S3FXrwFG55THu37DA", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:04:20"}
{"_id": "LdkYj5XYu35Dsf5yj", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n\n    all c:Component, p:c.parts & Component | c.position in p.position.*next \n\n}", "derivationOf": "WB5JgCr5v24TZnKED", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 16:52:49"}
{"_id": "WnBXGzka33YPTeBS4", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | c.parts not in c.^next\n}", "derivationOf": "93XedNo8gYkR9MGr6", "msg": "This name is ambiguous due to multiple matches:\nfun integer/next\nfun ordering/next", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:09:27"}
{"_id": "BNNBZxvtavNtMGzgj", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ko4YZD2uc9ygeaM5E", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 15:07:49"}
{"_id": "MBWWrDBw488gqgFrB", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in c.position.~^next\n}", "derivationOf": "g7jDjLDkRc9GhRdH5", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:11:48"}
{"_id": "aEwWP7CTwPS7BcSW7", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | no  c.parts.position.~^next\n}", "derivationOf": "AJTfHSAm4baXeeWTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:48:45"}
{"_id": "dt2cwK8EXfRae75hd", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "weC7LdcoNZXMiqpij", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:43:46"}
{"_id": "w6AGwcMQzPY36GYcA", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "HNPJFKpXFJjDT4K4s", "original": "jyS8Bmceejj9pLbTW", "theme": {"currentFramePosition": {}, "currentlyProjectedSigs": [], "generalSettings": {"currentLayout": "breadthfirst", "metaPrimSigs": [{"parent": null, "type": "univ"}, {"parent": "Product", "type": "Component"}, {"parent": "univ", "type": "Int"}, {"parent": "univ", "type": "Position"}, {"parent": "univ", "type": "Product"}, {"parent": "univ", "type": "RejectedBy"}, {"parent": "Product", "type": "Resource"}, {"parent": "univ", "type": "Robot"}, {"parent": "RejectedBy", "type": "ShouldBeAccepted"}, {"parent": "RejectedBy", "type": "ShouldBeRejected"}, {"parent": "univ", "type": "String"}, {"parent": "null", "type": "univ"}, {"parent": "univ", "type": "ordering/Ord"}, {"parent": "Int", "type": "seq/Int"}, {"parent": "Product", "type": "Component"}, {"parent": "univ", "type": "Int"}, {"parent": "univ", "type": "Position"}, {"parent": "univ", "type": "Product"}, {"parent": "univ", "type": "RejectedBy"}, {"parent": "Product", "type": "Resource"}, {"parent": "univ", "type": "Robot"}, {"parent": "RejectedBy", "type": "ShouldBeAccepted"}, {"parent": "RejectedBy", "type": "ShouldBeRejected"}, {"parent": "univ", "type": "String"}, {"parent": "null", "type": "univ"}, {"parent": "univ", "type": "ordering/Ord"}, {"parent": "Int", "type": "seq/Int"}], "metaSubsetSigs": []}, "nodePositions": {"Component0": {"x": 748.5602678571429, "y": 99.5}, "Component1": {"x": 698.65625, "y": 199}, "Position0": {"x": 598.8482142857143, "y": 99.5}, "Position1": {"x": 349.328125, "y": 199}, "Position2": {"x": 698.65625, "y": 298.5}, "Product": {"x": 349.328125, "y": 298.5}, "Robot0": {"x": 898.2723214285714, "y": 99.5}, "Robot1": {"x": 449.1361607142857, "y": 99.5}, "Robot2": {"x": 299.4241071428571, "y": 99.5}, "ShouldBeRejected": {"x": 149.71205357142856, "y": 99.5}}, "relationSettings": {"edgeColors": [{"color": "#0074D9", "relation": "First"}, {"color": "#0074D9", "relation": "Next"}, {"color": "#0074D9", "relation": "parts"}, {"color": "#0074D9", "relation": "position"}], "edgeStyles": [{"edgeStyle": "solid", "relation": "First"}, {"edgeStyle": "solid", "relation": "Next"}, {"edgeStyle": "solid", "relation": "parts"}, {"edgeStyle": "solid", "relation": "position"}], "showAsArcs": [{"relation": "general", "showAsArcs": true}, {"relation": "First", "showAsArcs": true}, {"relation": "Next", "showAsArcs": true}, {"relation": "parts", "showAsArcs": true}, {"relation": "position", "showAsArcs": true}, {"relation": "ShouldBeRejected", "showAsArcs": true}, {"relation": "ShouldBeAccepted", "showAsArcs": true}, {"relation": "ordering/Ord", "showAsArcs": true}, {"relation": "Position", "showAsArcs": true}, {"relation": "Robot", "showAsArcs": true}, {"relation": "Product", "showAsArcs": true}, {"relation": "Component", "showAsArcs": true}, {"relation": "Resource", "showAsArcs": true}], "showAsAttributes": [{"relation": "position", "showAsAttributes": false}, {"relation": "parts", "showAsAttributes": false}, {"relation": "First", "showAsAttributes": false}, {"relation": "Next", "showAsAttributes": false}]}, "sigSettings": {"nodeBorders": [{"border": "solid", "type": "univ"}, {"border": "inherit", "type": "Component"}, {"border": "inherit", "type": "Product"}, {"border": "inherit", "type": "Int"}, {"border": "inherit", "type": "Position"}, {"border": "inherit", "type": "Resource"}, {"border": "inherit", "type": "Robot"}, {"border": "inherit", "type": "ShouldBeRejected"}, {"border": "inherit", "type": "RejectedBy"}, {"border": "inherit", "type": "ordering/Ord"}, {"border": "inherit", "type": "seq/Int"}, {"border": "inherit", "type": "ShouldBeAccepted"}, {"border": "inherit", "type": "general"}], "nodeColors": [{"color": "#2ECC40", "type": "univ"}, {"color": "#01FF70", "type": "Component"}, {"color": "#FFDC00", "type": "Product"}, {"color": "inherit", "type": "Int"}, {"color": "#39CCCC", "type": "Position"}, {"color": "#3D9970", "type": "Resource"}, {"color": "#85144b", "type": "Robot"}, {"color": "#FF4136", "type": "ShouldBeRejected"}, {"color": "inherit", "type": "RejectedBy"}, {"color": "inherit", "type": "ordering/Ord"}, {"color": "inherit", "type": "seq/Int"}, {"color": "#FF4136", "type": "ShouldBeAccepted"}, {"color": "inherit", "type": "general"}], "nodeShapes": [{"shape": "ellipse", "type": "univ"}, {"shape": "inherit", "type": "Component"}, {"shape": "inherit", "type": "Product"}, {"shape": "inherit", "type": "Int"}, {"shape": "rectangle", "type": "Position"}, {"shape": "inherit", "type": "Resource"}, {"shape": "hexagon", "type": "Robot"}, {"shape": "octagon", "type": "ShouldBeRejected"}, {"shape": "inherit", "type": "RejectedBy"}, {"shape": "inherit", "type": "ordering/Ord"}, {"shape": "inherit", "type": "seq/Int"}, {"shape": "octagon", "type": "ShouldBeAccepted"}, {"shape": "inherit", "type": "general"}], "nodeVisibility": [{"type": "univ", "visibility": false}, {"type": "Int", "visibility": true}, {"type": "seq/Int", "visibility": true}, {"type": "general", "visibility": false}, {"type": "Component", "visibility": false}, {"type": "Position", "visibility": false}, {"type": "Resource", "visibility": false}, {"type": "Robot", "visibility": false}, {"type": "ShouldBeRejected", "visibility": false}, {"type": "ordering/Ord", "visibility": true}, {"type": "Product", "visibility": false}, {"type": "ShouldBeAccepted", "visibility": false}]}}, "time": "2019-10-17 10:57:07"}
{"_id": "TFg8MXgdQNavBTp4b", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "5CDpRhc37SK4JY9ik", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:01:26"}
{"_id": "Hj6ZP7itg7DBLP9TN", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component| c.position = Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "zewRCixDGaoyJ82pX", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:04:35"}
{"_id": "LRYyuskpzyztwRf7b", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | some p.c implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "m3bi6dDH2dnWARWAF", "msg": "This cannot be a legal relational join where\nleft hand side is p (type = {this/Position})\nright hand side is c (type = {this/Component})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:41:57"}
{"_id": "sit9tYYD5MgksxSYp", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in (c.parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ov9DfaEBdzo9PThyg", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-9 04:29:46"}
{"_id": "hD6mo63CSKcvM4ukp", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | (c.^parts).c not in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "PKmm8wrYmCLM9Jt2b", "msg": "This cannot be a legal relational join where\nleft hand side is c . ^ (this/Component <: parts) (type = {this/Product})\nright hand side is c (type = {this/Component})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:50:09"}
{"_id": "JAyAxW65vXCjfg8JJ", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | c not in c.*parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "BXwuJiGfP4XpSHe2r", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-9 04:40:01"}
{"_id": "ZwN5a8zq3X79rrL9D", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c<:(parts.c)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "Mi9yybKFMHRXo89pE", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:36:17"}
{"_id": "ibpDZBbZwydDmB7j2", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in ^c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "PK6AhRiBjvfANtR6q", "msg": "^ can be used only with a binary relation.\nInstead, its possible type(s) are:\n{this/Component}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 09:55:11"}
{"_id": "kG6tJJCywwK2QKbkM", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | Robot.position in c.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "MzLamobMi3pjoEnr4", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:05:25"}
{"_id": "8u3jki6mFc5QwTwX6", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | some c.p implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "HfyHmaaZLMMoREbtN", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:41:29"}
{"_id": "EcJg47duab6ocDrfA", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | c.position < c.prevs.position\n}", "derivationOf": "bKKzD54p6nyYCPkNt", "msg": "This must be an integer expression.\nInstead, it has the following possible type(s):\n{this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:44:29"}
{"_id": "PkT3ZqsgcwA9WZ5F4", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "FemRTPXBSRSvanEL9", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:00:20"}
{"_id": "Ec5Yr5FvSoXv8JLfM", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts  not in c.position.next\n}", "derivationOf": "GaGNnbH2sAGznx9dg", "msg": "This name is ambiguous due to multiple matches:\nfun integer/next\nfun ordering/next", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:10:50"}
{"_id": "EC3zcrhrCwhiSzDS2", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.parts):>Component).position not in (c.position).^next\n}", "derivationOf": "Yu8LFHg26aBkcFK2C", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:12:42"}
{"_id": "cepGWJQq4FXCqaPok", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "AutqvKkgk5p9eqpZ5", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-11-10 22:19:17"}
{"_id": "AxMFjo4i4RqePHpWh", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c & ^parts.c not in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "udF3wnmBYYonNzx4v", "msg": "!in can be used only between 2 expressions of the same arity.\nLeft type = {this/Component}\nRight type = {this/Component->this/Product}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:49:34"}
{"_id": "jTj8h6rvWsgM8Q97a", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n  \tall c:Component | c.parts.position in c.~^position\n}", "derivationOf": "fNDB44G9u9nxxR4mA", "msg": "This name is ambiguous due to multiple matches:\nfield this/Component <: position\nfield this/Robot <: position", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 19:46:13"}
{"_id": "GDmbKBwtp7ppGBtiW", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->c in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "myYzDvP8z9J3wJw7F", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:46:40"}
{"_id": "SKfJgGegt4cQYAco7", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component, p:Position | some r:Robot | c.p in position implies r.p in Position  \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "YMphTMypzRZrz23jw", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 15:58:19"}
{"_id": "kQSqJzuJKtw4FRC4N", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "7Z7wyiRNhunA9tMRg", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 15:53:43"}
{"_id": "CZA4YJ6sMwSgjTg8e", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->c in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "og2bX9oq64Xu5XNrn", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:46:15"}
{"_id": "L5jj3wKuncFNzbTRr", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tno Component.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "KcrzctsroJaou8KaS", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:51:15"}
{"_id": "izmvrHsgvhJo7G3yt", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | c.parts in c.^~next\n}", "derivationOf": "99DJkdMHZ2aXTPn55", "msg": "This name is ambiguous due to multiple matches:\nfun integer/next\nfun ordering/next", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:08:58"}
{"_id": "JBpN4TeY5S5yYCskt", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c.^parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    Robot.position = Component.position \n}", "derivationOf": "oz2Dufom2t9MLQRBh", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:56:23"}
{"_id": "guheshZRDhB5qXQk8", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 20:24:27"}
{"_id": "zewRCixDGaoyJ82pX", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component, r:Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "xwvrQQApH4pTZ5RdB", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:04:27"}
{"_id": "xJj83T8obqsCs6mRf", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in (c.^position.~^next)\n}", "derivationOf": "SyvKgFQfuinD52xFR", "msg": "^ <(this/Component <: position);(this/Robot <: position);> is redundant since its domain and range are disjoint: {this/Robot->this/Position, this/Component->this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:38:41"}
{"_id": "frz4thF9bHj3Qa48i", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c<:parts) & (parts.c)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "2yWqnmH4LeR4Y7vPE", "msg": "& can be used only between 2 expressions of the same arity.\nLeft type = {this/Component->this/Product}\nRight type = {this/Component}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:34:15"}
{"_id": "h6hqZcBZrbjwxLR2M", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c<:parts in iden\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "auxMRuFAhoeZ3KAGf", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:32:19"}
{"_id": "og2bX9oq64Xu5XNrn", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "dt2cwK8EXfRae75hd", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:44:58"}
{"_id": "xDztjhzkNEy6RCnis", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tno (Component.*parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "YtgifHvJec8HRYKdB", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:52:11"}
{"_id": "iHnc3Yk4eFFdXiWWS", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | c.position < c.prevs\n}", "derivationOf": "gNHPhJ9MN73QEB26J", "msg": "This must be an integer expression.\nInstead, it has the following possible type(s):\n{this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:43:48"}
{"_id": "qEwGEKkFTKA7hMApv", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | c.parts in c.^~next\n}", "derivationOf": "izmvrHsgvhJo7G3yt", "msg": "This name is ambiguous due to multiple matches:\nfun integer/next\nfun ordering/next", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:09:08"}
{"_id": "HXXfLY88SuaGxwiCQ", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.^parts) & Component).position not in (c.position).^next or no c.^parts\n}", "derivationOf": "CCgRd456bPqco4vC8", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:58:41"}
{"_id": "m3bi6dDH2dnWARWAF", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\t\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ZZ8WhaRk6SH9ZMjbE", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:41:42"}
{"_id": "8nqxyypbuXAtoagmd", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | c.position > p.position\n}", "derivationOf": "aYAxhv838QDSfpYDo", "msg": "This must be an integer expression.\nInstead, it has the following possible type(s):\n{this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:48:34"}
{"_id": "HNPJFKpXFJjDT4K4s", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "t67WRB3GW7wnc3cSb", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:56:25"}
{"_id": "oJLPt3wcTuPMT4fjN", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 15:07:22"}
{"_id": "A3rCMmGBbsasLTdm2", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component,p:Product, r:Robot,pos1,pos2:Position| c->p in parts and p->pos1 in position and r->pos2 in position implies pos1=pos2\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "yGAjCwo6WRZW8tDKN", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-11-10 23:06:50"}
{"_id": "pTR85nLB3Wcacb5v9", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "sit9tYYD5MgksxSYp", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-9 04:32:24"}
{"_id": "myYzDvP8z9J3wJw7F", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->c in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "CZA4YJ6sMwSgjTg8e", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:46:33"}
{"_id": "jNhKLMEz5W7KiCyFk", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->parts->c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ZwN5a8zq3X79rrL9D", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:38:24"}
{"_id": "BXwuJiGfP4XpSHe2r", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | c not in c.*succ\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "5AiC2meFP47w7XtKL", "msg": "The name \"succ\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-9 04:39:41"}
{"_id": "fFHAYwaeZef5MAedv", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(c<:parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "P7Tc3dowxG7YTi4a5", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:30:56"}
{"_id": "weC7LdcoNZXMiqpij", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "6eyKCT7wehDbdbaGj", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:43:42"}
{"_id": "n9nkEiwZSXNqXcsLG", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c.*parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "s7DF344fNmo9nvbfe", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:53:16"}
{"_id": "4FawfKYue6j9QMR8n", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position in c.position.~^next\n}", "derivationOf": "aEwWP7CTwPS7BcSW7", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:52:51"}
{"_id": "xMmYtBFgcsQCT6Bop", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(c<:parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ysqnvyLKkeNgz6bWa", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:31:08"}
{"_id": "KNF9y8p4GBDtPzBqk", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component , some r:Robot | r->(c.position) in position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "PPe4TE573KE54Wsk5", "msg": "There are 8 possible tokens that can appear here:\nNAME disj exh part private seq this var", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 09:59:11"}
{"_id": "CCoE2ncmAuBSmeuYL", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.position not in c.position.^next\n}", "derivationOf": "zeTNT8LdckiqftdAE", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 19:41:42"}
{"_id": "quEsaoLZ2Nyg4zcS4", "cmd_i": 0, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Componet.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "guheshZRDhB5qXQk8", "msg": "The name \"Componet\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 20:24:52"}
{"_id": "CCgRd456bPqco4vC8", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | ((c.^parts) & Component).position not in (c.position).^next\n}", "derivationOf": "PFJgZTTRRLNeEubq5", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:56:48"}
{"_id": "KcrzctsroJaou8KaS", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tno Componet.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "hD6mo63CSKcvM4ukp", "msg": "The name \"Componet\" cannot be found.", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:51:07"}
{"_id": "udF3wnmBYYonNzx4v", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c->c not in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "zHxsHSNvgPcqnK6Ao", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:48:07"}
{"_id": "MzLamobMi3pjoEnr4", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some Robot.position in c.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "Hj6ZP7itg7DBLP9TN", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:05:14"}
{"_id": "7Z7wyiRNhunA9tMRg", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "oJLPt3wcTuPMT4fjN", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 15:08:52"}
{"_id": "gNHPhJ9MN73QEB26J", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "SKfJgGegt4cQYAco7", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 16:26:47"}
{"_id": "SyvKgFQfuinD52xFR", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts(c.^position.~^next)\n}", "derivationOf": "g483cTWFyfLtC2mPb", "msg": "This must be a formula expression.\nInstead, it has the following possible type(s):\n{this/Product}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:38:29"}
{"_id": "YtgifHvJec8HRYKdB", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tno (Component.^parts)<:Component\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "5q3azcXDjqeesaHtX", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:51:44"}
{"_id": "fiZQ9Zc7D2c6qRtze", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n  \n  \n  all c:Component | some c.parts.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "A3rCMmGBbsasLTdm2", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-11-10 23:13:31"}
{"_id": "TohkCuWEjvy2hgAcg", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "DSPospR2YPFRwFSur", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:46:50"}
{"_id": "mzGW5wvwimXczjpkx", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "W6oHwdggaEKonZhTC", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:29:00"}
{"_id": "kJz4gZ4ZTtmystgHj", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "tBPGBfgHCG4urYjEB", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 15:07:03"}
{"_id": "zziKDgMCHKrfAn6ci", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | r.position = c.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | all p:c.parts | p not in c.^parts\n}", "derivationOf": "yhEj5CLi7PoyNDf9A", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:41:29"}
{"_id": "QjnWNw3A9pCEyHWj7", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in c.position.~^next\n}", "derivationOf": "b4butKMAmMdS8Q8zq", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:09:38"}
{"_id": "98PXix3jxgeGjmLzc", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "ef4gWiJqbsax2SC23", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:28:22"}
{"_id": "Mkxt4xMQKp7bi4D4J", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 09:14:41"}
{"_id": "YTd3Bp5GHRC4vwo2K", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.^parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "oiAAQXWfwDgqFfuoQ", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-22 11:03:34"}
{"_id": "DjxA3Bmec2PcYXi4m", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->c in parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tComponent.position in Robot.position\n} \n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "TohkCuWEjvy2hgAcg", "msg": "This must be a set or relation.\nInstead, it has the following possible type(s):\n{PrimitiveBoolean}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:47:19"}
{"_id": "hG9Scf2YKSuBFHh5C", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\n\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some r: Robot | c.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c : Component | all p : c.parts | some pos : c.position.prevs | p.position = pos", "derivationOf": "4F4AR3qdxnKbCyYYB", "msg": "There are 38 possible tokens that can appear here:\n! # ( * @ Int NAME NUMBER STRING String Time ^ after all always before disj eventually fun historically iden int let lone no none once one pred seq set some sum this univ { } ~", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-7 19:42:06"}
{"_id": "YMphTMypzRZrz23jw", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "kQSqJzuJKtw4FRC4N", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 15:54:02"}
{"_id": "5CDpRhc37SK4JY9ik", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "PkT3ZqsgcwA9WZ5F4", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:00:44"}
{"_id": "Yu8LFHg26aBkcFK2C", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component | (c.position) in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c: Component | (c.parts).position not in (c.position).^next\n}", "derivationOf": "F6mPCaohJWW5zjjGf", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:10:31"}
{"_id": "yhEj5CLi7PoyNDf9A", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | r.position = c.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "pnbSywBb2egSDGABa", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2020-1-8 16:08:39"}
{"_id": "rq3dHn4G42LQk4h9m", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts.position in c.position.~^next\n}", "derivationOf": "ft5ByRZdr98EpjnKD", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-17 10:12:58"}
{"_id": "ft5ByRZdr98EpjnKD", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component | c.parts in c.position.~^next\n}", "derivationOf": "MBWWrDBw488gqgFrB", "msg": "Subset operator is redundant, because the left and right subexpressions are always disjoint.\nLeft type = {this/Product}\nRight type = {this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:12:29"}
{"_id": "ysqnvyLKkeNgz6bWa", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c.(c<:parts)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "fFHAYwaeZef5MAedv", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-18 21:31:04"}
{"_id": "rtorT6dhjjcFTEuoT", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "pgfnSZwRpsryCyTGB", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-22 11:01:41"}
{"_id": "BS78i226roaArpT9M", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.^parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n  \tsome r:Robot | Component.position = r.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "yMxiATrfELowQRAJ7", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 11:06:14"}
{"_id": "2yWqnmH4LeR4Y7vPE", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c<:parts).c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "e8HfMFaC4hcXNsz5K", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:33:21"}
{"_id": "Gd9oYvfX8JirfXmE4", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component.position, r:Robot | some r.position & c\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "TzRcf27oyqFX5ad3X", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 16:06:53"}
{"_id": "aYAxhv838QDSfpYDo", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | some r:Robot | c.position = r.position   \n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    all c:Component, p:c.parts | c.position < p.position\n}", "derivationOf": "EcJg47duab6ocDrfA", "msg": "This must be an integer expression.\nInstead, it has the following possible type(s):\n{this/Position}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2020-1-8 16:48:24"}
{"_id": "W6oHwdggaEKonZhTC", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "98PXix3jxgeGjmLzc", "msg": "This variable is unused.", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:28:51"}
{"_id": "NNgcJonp3wxmX3YXE", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-11-23 15:40:44"}
{"_id": "b4butKMAmMdS8Q8zq", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component |  c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "eEWHQFwfAmfqNXbL7", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-17 10:04:32"}
{"_id": "Wqf3PMPiNJAZDFBFY", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c<:parts).c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "3sJNrHa3SW699h6HR", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:35:31"}
{"_id": "E5saYuEgsKLJn9BLi", "cmd_c": true, "cmd_i": 3, "cmd_n": "Inv4OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \t\n  \tall c:Component | c.parts.position in c.position\n}", "derivationOf": "CCoE2ncmAuBSmeuYL", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 19:43:18"}
{"_id": "yGAjCwo6WRZW8tDKN", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts  \n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component,p:Product |some r:Robot,pos1,pos2:Position| c->p in parts and p->pos1 in position and r->pos2 in position implies pos1=pos2\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "AT2d6FWXQJDXwN9Fs", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-11-10 23:06:26"}
{"_id": "hzKMq8w7PzCuM5MrB", "cmd_i": 3, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c:Component | c.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n  \tall c:Component | c.part.position in c.position.~^next\n}", "derivationOf": "4FawfKYue6j9QMR8n", "msg": "There are 28 possible tokens that can appear here:\n( * @ Int NAME NUMBER STRING String Time ^ all disj fun iden int let lone no none one pred seq some sum this univ { ~", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 10:53:40"}
{"_id": "x45tuPxpMLGzgaWL5", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tsome Component.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jyS8Bmceejj9pLbTW", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-22 11:01:14"}
{"_id": "NegLr9xynWhzWgdeP", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c<:(parts.c)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "Wqf3PMPiNJAZDFBFY", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2019-10-18 21:36:03"}
{"_id": "f8eNqbES83mNemabL", "cmd_c": true, "cmd_i": 2, "cmd_n": "Inv3OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | no c.^parts & c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n  \tComponent.position in Robot.position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "BS78i226roaArpT9M", "original": "jyS8Bmceejj9pLbTW", "sat": 0, "time": "2019-10-22 11:06:49"}
{"_id": "uJDkG4ft6x89r6b66", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no c->parts->c\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | some c.p implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "jNhKLMEz5W7KiCyFk", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:40:50"}
{"_id": "P9Z3WxurmjqoBx5xg", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c: Component , some r:Robot | r->(c.position) in Robot<:position\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "KNF9y8p4GBDtPzBqk", "msg": "There are 8 possible tokens that can appear here:\nNAME disj exh part private seq this var", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-17 09:59:36"}
{"_id": "yrEa4shyBtRWwsPE9", "cmd_c": true, "cmd_i": 0, "cmd_n": "Inv1OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | c not in c.^parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "JAyAxW65vXCjfg8JJ", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-9 04:40:09"}
{"_id": "njFA9mHMqqeB3w6Th", "cmd_i": 2, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\t\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\tall c : Component | some p : Position | c.p implies some Robot.p\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "LRYyuskpzyztwRf7b", "msg": "This cannot be a legal relational join where\nleft hand side is c (type = {this/Component})\nright hand side is p (type = {this/Position})", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:42:12"}
{"_id": "K3qHfbt6i729gQbXM", "cmd_c": true, "cmd_i": 1, "cmd_n": "Inv2OK", "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c:Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c:Component | c not in c.parts\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "BNNBZxvtavNtMGzgj", "original": "jyS8Bmceejj9pLbTW", "sat": 1, "time": "2020-1-8 15:08:00"}
{"_id": "3sJNrHa3SW699h6HR", "cmd_i": 1, "code": "open util/ordering[Position]\n\n// Consider the following model of an automated production line\n// The production line consists of several positions in sequence\nsig Position {}\n\n// Products are either components assembled in the production line or \n// other resources (e.g. pre-assembled products or base materials)\nsig Product {}\n\n// Components are assembled in a given position from other parts\nsig Component extends Product {\n    parts : set Product,\n    position : one Position\n}\nsig Resource extends Product {}\n\n// Robots work somewhere in the production line\nsig Robot {\n        position : one Position\n}\n\n// Specify the following invariants!\n// You can check their correctness with the different commands and\n// specifying a given invariant you can assume the others to be true.\npred Inv1 { // A component requires at least one part\n\tall c : Component | some c.parts\n}\n\n\npred Inv2 { // A component cannot be a part of itself\n\tall c : Component | no (c<:parts) & (parts<:c)\n}\n\n\npred Inv3 { // The position where a component is assembled must have at least one robot\n\n}\n\n\npred Inv4 { // The parts required by a component cannot be assembled in a later position\n    \n}", "derivationOf": "frz4thF9bHj3Qa48i", "msg": "This must be a unary set, but instead it has the following possible type(s):\n{this/Component->this/Product}", "original": "jyS8Bmceejj9pLbTW", "sat": -1, "time": "2019-10-18 21:34:42"}