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