1a+  ACE:  Every security-component is a core-component.
1a+  SOUL: ?x isCoreComponent if ?x isSecurityComponent
1a+  PL:   is_core_component(X) :- is_security_component(X).
1b-  ACE:  Every legacy-component is a core-component.
1b-  SOUL: ?x isCoreComponent if ?x isLegacyComponent
1b-  PL:   is_core_component(X) :- is_legacy_component(X).
2a-  ACE:  Every component that is not a security-component is a legacy-component.
2a-  SOUL: ?x isLegacyComponent if ?x isComponent, not( ?x isSecurityComponent )
2a-  PL:   is_legacy_component(X) :- is_component(X), \+ is_security_component(X).
2b+  ACE:  Every component that is not a core-component is a legacy-component.
2b+  SOUL: ?x isLegacyComponent if ?x isComponent, not( ?x isCoreComponent )
2b+  PL:   is_legacy_component(X) :- is_component(X), \+ is_core_component(X).
3a+  ACE:  Every component that uses a legacy-component is a security-component.
3a+  SOUL: ?x isSecurityComponent if ?x isComponent, ?y isLegacyComponent, ?x uses: ?y
3a+  PL:   is_security_component(X) :- is_component(X), is_legacy_component(Y), uses(X,Y).
3b-  ACE:  Every component that monitors a legacy-component is a core-component.
3b-  SOUL: ?x isCoreComponent if ?x isComponent, ?y isLegacyComponent, ?x monitors: ?y
3b-  PL:   is_core_component(X) :- is_component(X), is_legacy_component(Y), monitors(X,Y).
4a-  ACE:  Every component that is used by a security-component is a core-component.
4a-  SOUL: ?x isCoreComponent if ?x isComponent, ?y isSecurityComponent, ?y uses: ?x
4a-  PL:   is_core_component(X) :- is_component(X), is_security_component(Y), uses(Y,X).
4b+  ACE:  Every component that is used by a security-component is a legacy-component.
4b+  SOUL: ?x isLegacyComponent if ?x isComponent, ?y isSecurityComponent, ?y uses: ?x
4b+  PL:   is_legacy_component(X) :- is_component(X), is_security_component(Y), uses(Y,X).
5a+  ACE:  Every component that is notified by CompA is a security-component.
5a+  SOUL: ?x isSecurityComponent if ?x isComponent, CompA notifies: ?x
5a+  PL:   is_security_component(X) :- is_component(X), notifies(compA,X).
5b-  ACE:  Every component that is monitored by CompD is a legacy-component.
5b-  SOUL: ?x isLegacyComponent if ?x isComponent, CompD monitors: ?x
5b-  PL:   is_legacy_component(X) :- is_component(X), monitors(compD,X).
6a-  ACE:  Every core-component that is used by a component notifies the component.
6a-  SOUL: ?x notifies: ?y if ?x isCoreComponent, ?y isComponent, ?y uses: ?x
6a-  PL:   notifies(X,Y) :- is_core_component(X), is_component(Y), uses(Y,X).
6b+  ACE:  Every legacy-component that is used by a component notifies the component.
6b+  SOUL: ?x notifies: ?y if ?x isLegacyComponent, ?y isComponent, ?y uses: ?x
6b+  PL:   notifies(X,Y) :- is_legacy_component(X), is_component(Y), uses(Y,X).
7a-  ACE:  Every security-component uses CompA.
7a-  SOUL: ?x uses: CompA if ?x isSecurityComponent
7a-  PL:   uses(X,compA) :- is_security_component(X).
7b+  ACE:  Every legacy-component notifies CompC.
7b+  SOUL: ?x notifies: CompC if ?x isLegacyComponent
7b+  PL:   notifies(X,compC) :- is_legacy_component(X).
8a+  ACE:  Every legacy-component that does not notify CompE is monitored by CompD.
8a+  SOUL: CompD monitors: ?x if ?x isLegacyComponent, not( ?x notify: CompE )
8a+  PL:   monitors(compD,X) :- is_legacy_component(X), \+ notify(X,compE).
8b-  ACE:  Every security-component that does not use CompB is notified by CompD.
8b-  SOUL: CompD notifies: ?x if ?x isSecurityComponent, not( ?x uses: CompB )
8b-  PL:   notifies(compD,X) :- is_security_component(X), \+ uses(X,compB).
9a+  ACE:  Every component that is a security-component or that uses CompC is a core-component.
9a+  SOUL: ?x isCoreComponent if ?x isComponent, or( ?x isSecurityComponent, ?x uses: CompC )
9a+  PL:   is_core_component(X) :- is_component(X), ( is_security_component(X) ; uses(X,compC) ).
9b-  ACE:  Every component that is a legacy-component or that monitors CompE is a core-component.
9b-  SOUL: ?x isCoreComponent if ?x isComponent, or( ?x isLegacyComponent, ?x monitors: CompE )
9b-  PL:   is_core_component(X) :- is_component(X), ( is_legacy_component(X) ; monitors(X,compE) ).
10a- ACE:  Every component that notifies CompE or that is used by CompC is monitored by CompD.
10a- SOUL: CompD monitors: ?x if ?x isComponent, or( ?x notifies: CompE, CompC uses: ?x )
10a- PL:   monitors(compD,X) :- is_component(X), ( notifies(X,compE) ; uses(compC,X) ).
10b+ ACE:  Every component that uses CompA or that is used by CompC is monitored by CompD.
10b+ SOUL: CompD monitors: ?x if ?x isComponent, or( ?x uses: CompA, CompC uses: ?x )
10b+ PL:   monitors(compD,X) :- is_component(X), ( uses(X,compA) ; uses(compC,X) ).

