Merge pull request #48 from kris7t/validator

Improve content assist and validator

39 files changed, 2148 insertions, 147 deletions

diff --git a/subprojects/frontend/config/detectDevModeOptions.ts b/subprojects/frontend/config/detectDevModeOptions.ts
index 6052e047..7a3de4cb 100644
--- a/subprojects/frontend/config/detectDevModeOptions.ts
+++ b/subprojects/frontend/config/detectDevModeOptions.ts
@@ -63,6 +63,11 @@ export default function detectDevModeOptions(): DevModeOptions {
   const api = detectListenOptions('API', '127.0.0.1', 1312);
   const publicAddress = detectListenOptions('PUBLIC', listen.host, listen.port);
 
+  if (listen.secure) {
+    // Since nodejs 20, we'd need to pass in HTTPS options manually.
+    throw new Error(`Preview on secure port ${listen.port} is not supported`);
+  }
+
   const backendConfig: BackendConfig = {
     webSocketURL: `${listenURL(publicAddress, 'ws')}/${API_ENDPOINT}`,
   };
@@ -75,7 +80,6 @@ export default function detectDevModeOptions(): DevModeOptions {
       host: listen.host,
       port: listen.port,
       strictPort: true,
-      https: listen.secure,
       headers: {
         // Enable strict origin isolation, see e.g.,
         // https://github.com/vitejs/vite/issues/3909#issuecomment-1065893956
diff --git a/subprojects/frontend/package.json b/subprojects/frontend/package.json
index 748cc78d..e710a506 100644
--- a/subprojects/frontend/package.json
+++ b/subprojects/frontend/package.json
@@ -28,74 +28,74 @@
   },
   "homepage": "https://refinery.tools",
   "dependencies": {
-    "@codemirror/autocomplete": "^6.10.2",
+    "@codemirror/autocomplete": "^6.11.0",
     "@codemirror/commands": "^6.3.0",
-    "@codemirror/language": "^6.9.1",
+    "@codemirror/language": "^6.9.2",
     "@codemirror/lint": "^6.4.2",
     "@codemirror/search": "^6.5.4",
     "@codemirror/state": "^6.3.1",
-    "@codemirror/view": "^6.21.3",
+    "@codemirror/view": "^6.22.0",
     "@emotion/react": "^11.11.1",
     "@emotion/styled": "^11.11.0",
-    "@fontsource-variable/jetbrains-mono": "^5.0.16",
-    "@fontsource-variable/open-sans": "^5.0.16",
+    "@fontsource-variable/jetbrains-mono": "^5.0.18",
+    "@fontsource-variable/open-sans": "^5.0.18",
     "@hpcc-js/wasm": "^2.14.1",
-    "@lezer/common": "^1.1.0",
-    "@lezer/highlight": "^1.1.6",
-    "@lezer/lr": "^1.3.13",
+    "@lezer/common": "^1.1.1",
+    "@lezer/highlight": "^1.2.0",
+    "@lezer/lr": "^1.3.14",
     "@material-icons/svg": "^1.0.33",
-    "@mui/icons-material": "5.14.14",
-    "@mui/material": "5.14.14",
-    "@mui/system": "^5.14.14",
-    "@mui/x-data-grid": "^6.16.2",
+    "@mui/icons-material": "5.14.18",
+    "@mui/material": "5.14.18",
+    "@mui/system": "^5.14.18",
+    "@mui/x-data-grid": "^6.18.1",
     "ansi-styles": "^6.2.1",
     "csstype": "^3.1.2",
     "d3": "^7.8.5",
-    "d3-graphviz": "patch:d3-graphviz@npm%3A5.1.0#~/.yarn/patches/d3-graphviz-npm-5.1.0-ba6bed3fec.patch",
+    "d3-graphviz": "patch:d3-graphviz@npm%3A5.2.0#~/.yarn/patches/d3-graphviz-npm-5.2.0-161b1fbad4.patch",
     "d3-selection": "^3.0.0",
     "d3-zoom": "patch:d3-zoom@npm%3A3.0.0#~/.yarn/patches/d3-zoom-npm-3.0.0-18f706a421.patch",
     "escape-string-regexp": "^5.0.0",
     "lodash-es": "^4.17.21",
     "loglevel": "^1.8.1",
     "loglevel-plugin-prefix": "^0.8.4",
-    "mobx": "^6.10.2",
+    "mobx": "^6.11.0",
     "mobx-react-lite": "^4.0.5",
     "ms": "^2.1.3",
-    "nanoid": "^5.0.2",
+    "nanoid": "^5.0.3",
     "notistack": "^3.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-resize-detector": "^9.1.0",
-    "xstate": "^4.38.2",
+    "xstate": "^4.38.3",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@lezer/generator": "^1.5.1",
-    "@types/d3": "^7.4.2",
-    "@types/d3-graphviz": "^2.6.9",
-    "@types/d3-selection": "^3.0.8",
-    "@types/d3-zoom": "^3.0.6",
-    "@types/eslint": "^8.44.6",
-    "@types/html-minifier-terser": "^7.0.1",
-    "@types/lodash-es": "^4.17.10",
-    "@types/micromatch": "^4.0.4",
-    "@types/ms": "^0.7.33",
-    "@types/node": "^18.18.6",
-    "@types/pnpapi": "^0.0.4",
-    "@types/react": "^18.2.29",
-    "@types/react-dom": "^18.2.14",
-    "@typescript-eslint/eslint-plugin": "^6.8.0",
-    "@typescript-eslint/parser": "^6.8.0",
-    "@vitejs/plugin-react-swc": "^3.4.0",
-    "@xstate/cli": "^0.5.7",
+    "@types/d3": "^7.4.3",
+    "@types/d3-graphviz": "^2.6.10",
+    "@types/d3-selection": "^3.0.10",
+    "@types/d3-zoom": "^3.0.8",
+    "@types/eslint": "^8.44.7",
+    "@types/html-minifier-terser": "^7.0.2",
+    "@types/lodash-es": "^4.17.11",
+    "@types/micromatch": "^4.0.5",
+    "@types/ms": "^0.7.34",
+    "@types/node": "^20.9.2",
+    "@types/pnpapi": "^0.0.5",
+    "@types/react": "^18.2.37",
+    "@types/react-dom": "^18.2.15",
+    "@typescript-eslint/eslint-plugin": "^6.11.0",
+    "@typescript-eslint/parser": "^6.11.0",
+    "@vitejs/plugin-react-swc": "^3.5.0",
+    "@xstate/cli": "^0.5.11",
     "cross-env": "^7.0.3",
-    "eslint": "^8.51.0",
+    "eslint": "^8.54.0",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-airbnb-typescript": "^17.1.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-jsx-a11y": "^6.7.1",
+    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-jsx-a11y": "^6.8.0",
     "eslint-plugin-mobx": "^0.0.9",
     "eslint-plugin-prettier": "^5.0.1",
     "eslint-plugin-react": "^7.33.2",
@@ -103,10 +103,10 @@
     "html-minifier-terser": "^7.2.0",
     "micromatch": "^4.0.5",
     "pnpapi": "^0.0.0",
-    "prettier": "^3.0.3",
+    "prettier": "^3.1.0",
     "typescript": "5.2.2",
-    "vite": "^4.5.0",
-    "vite-plugin-pwa": "^0.16.5",
+    "vite": "^5.0.0",
+    "vite-plugin-pwa": "^0.17.0",
     "workbox-window": "^7.0.0"
   }
 }
diff --git a/subprojects/frontend/src/DirectionalSplitPane.tsx b/subprojects/frontend/src/DirectionalSplitPane.tsx
index 59c8b739..110bb202 100644
--- a/subprojects/frontend/src/DirectionalSplitPane.tsx
+++ b/subprojects/frontend/src/DirectionalSplitPane.tsx
@@ -64,9 +64,8 @@ export default function DirectionalSplitPane({
           [axis]: '0px',
           display: showLeftOnly || showRightOnly ? 'none' : 'flex',
           flexDirection: direction,
-          [horizontalSplit
-            ? 'borderBottom'
-            : 'borderRight']: `1px solid ${theme.palette.outer.border}`,
+          [horizontalSplit ? 'borderBottom' : 'borderRight']:
+            `1px solid ${theme.palette.outer.border}`,
         }}
       >
         <Box
diff --git a/subprojects/frontend/src/graph/VisibilityDialog.tsx b/subprojects/frontend/src/graph/VisibilityDialog.tsx
index f1fef28b..bfdcd59f 100644
--- a/subprojects/frontend/src/graph/VisibilityDialog.tsx
+++ b/subprojects/frontend/src/graph/VisibilityDialog.tsx
@@ -210,7 +210,10 @@ function VisibilityDialog({
             }
           />
         </td>
-        <td onClick={() => graph.cycleVisibility(name)}>
+        <td
+          onClick={() => graph.cycleVisibility(name)}
+          aria-label="Toggle visiblity"
+        >
           <div className="VisibilityDialog-nowrap">
             <RelationName metadata={metadata} abbreviate={graph.abbreviate} />
           </div>
@@ -261,10 +264,10 @@ function VisibilityDialog({
           <table cellSpacing={0}>
             <thead>
               <tr>
-                <th>
+                <th aria-label="Show true and error values">
                   <LabelIcon />
                 </th>
-                <th>
+                <th aria-label="Show unknown values">
                   <LabelOutlinedIcon />
                 </th>
                 <th>Symbol</th>
diff --git a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/contentassist/ProblemCrossrefProposalProvider.java b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/contentassist/ProblemCrossrefProposalProvider.java
index ea90a82e..166b4400 100644
--- a/subprojects/language-ide/src/main/java/tools/refinery/language/ide/contentassist/ProblemCrossrefProposalProvider.java
+++ b/subprojects/language-ide/src/main/java/tools/refinery/language/ide/contentassist/ProblemCrossrefProposalProvider.java
@@ -6,9 +6,12 @@
 package tools.refinery.language.ide.contentassist;
 
 import com.google.inject.Inject;
+import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.xtext.CrossReference;
+import org.eclipse.xtext.EcoreUtil2;
 import org.eclipse.xtext.GrammarUtil;
 import org.eclipse.xtext.ide.editor.contentassist.ContentAssistContext;
 import org.eclipse.xtext.ide.editor.contentassist.IdeCrossrefProposalProvider;
@@ -16,10 +19,14 @@ import org.eclipse.xtext.naming.QualifiedName;
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
 import org.eclipse.xtext.resource.IEObjectDescription;
 import org.eclipse.xtext.scoping.IScope;
-import tools.refinery.language.model.problem.Problem;
+import org.eclipse.xtext.xtext.CurrentTypeFinder;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.language.model.problem.*;
 import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
-import tools.refinery.language.resource.ReferenceCounter;
+import tools.refinery.language.utils.BuiltinSymbols;
+import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
+import tools.refinery.language.validation.ReferenceCounter;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -28,8 +35,14 @@ import java.util.Objects;
 
 public class ProblemCrossrefProposalProvider extends IdeCrossrefProposalProvider {
         @Inject
+        private CurrentTypeFinder currentTypeFinder;
+
+        @Inject
         private ReferenceCounter referenceCounter;
 
+        @Inject
+        private ProblemDesugarer desugarer;
+
         @Override
         protected Iterable<IEObjectDescription> queryScope(IScope scope, CrossReference crossReference,
                                                                                                            ContentAssistContext context) {
@@ -49,7 +62,7 @@ public class ProblemCrossrefProposalProvider extends IdeCrossrefProposalProvider
                 for (var candidates : eObjectDescriptionsByName.values()) {
                         if (candidates.size() == 1) {
                                 var candidate = candidates.get(0);
-                                if (shouldBeVisible(candidate)) {
+                                if (shouldBeVisible(candidate, crossReference, context)) {
                                         eObjectDescriptions.add(candidate);
                                 }
                         }
@@ -81,9 +94,106 @@ public class ProblemCrossrefProposalProvider extends IdeCrossrefProposalProvider
                 return true;
         }
 
-        protected boolean shouldBeVisible(IEObjectDescription candidate) {
+        protected boolean shouldBeVisible(IEObjectDescription candidate, CrossReference crossReference,
+                                                                          ContentAssistContext context) {
                 var errorPredicate = candidate.getUserData(ProblemResourceDescriptionStrategy.ERROR_PREDICATE);
-                return !ProblemResourceDescriptionStrategy.ERROR_PREDICATE_TRUE.equals(errorPredicate);
+                if (ProblemResourceDescriptionStrategy.ERROR_PREDICATE_TRUE.equals(errorPredicate)) {
+                        return false;
+                }
+
+                var eReference = getEReference(crossReference);
+                if (eReference == null) {
+                        return true;
+                }
+
+                var candidateEObjectOrProxy = candidate.getEObjectOrProxy();
+
+                if (eReference.equals(ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) &&
+                                candidateEObjectOrProxy instanceof ReferenceDeclaration candidateReferenceDeclaration) {
+                        return oppositeShouldBeVisible(candidateReferenceDeclaration, context);
+                }
+
+                var builtinSymbolsOption = desugarer.getBuiltinSymbols(context.getRootModel());
+                if (builtinSymbolsOption.isEmpty()) {
+                        return true;
+                }
+                var builtinSymbols = builtinSymbolsOption.get();
+
+                return builtinSymbolAwareShouldBeVisible(candidate, context, eReference, builtinSymbols,
+                                candidateEObjectOrProxy);
+        }
+
+        private static boolean oppositeShouldBeVisible(ReferenceDeclaration candidateReferenceDeclaration,
+                                                                                                   ContentAssistContext context) {
+                var referenceDeclaration = EcoreUtil2.getContainerOfType(context.getCurrentModel(),
+                                ReferenceDeclaration.class);
+                if (referenceDeclaration == null) {
+                        return true;
+                }
+                var classDeclaration = EcoreUtil2.getContainerOfType(referenceDeclaration, ClassDeclaration.class);
+                if (classDeclaration == null) {
+                        return true;
+                }
+                var oppositeType = candidateReferenceDeclaration.getReferenceType();
+                if (oppositeType == null) {
+                        return true;
+                }
+                var resolvedOppositeType = EcoreUtil.resolve(oppositeType, candidateReferenceDeclaration);
+                return classDeclaration.equals(resolvedOppositeType);
+        }
+
+        private boolean builtinSymbolAwareShouldBeVisible(
+                        IEObjectDescription candidate, ContentAssistContext context, EReference eReference,
+                        BuiltinSymbols builtinSymbols, EObject candidateEObjectOrProxy) {
+                if (eReference.equals(ProblemPackage.Literals.REFERENCE_DECLARATION__REFERENCE_TYPE) &&
+                                context.getCurrentModel() instanceof ReferenceDeclaration referenceDeclaration &&
+                                (referenceDeclaration.getKind() == ReferenceKind.CONTAINMENT ||
+                                                referenceDeclaration.getKind() == ReferenceKind.CONTAINER)) {
+                        // Containment or container references must have a class type.
+                        // We don't support {@code node} as a container or contained type.
+                        return ProblemPackage.Literals.CLASS_DECLARATION.isSuperTypeOf(candidate.getEClass()) &&
+                                        !builtinSymbols.node().equals(candidateEObjectOrProxy);
+                }
+
+                if (eReference.equals(ProblemPackage.Literals.REFERENCE_DECLARATION__REFERENCE_TYPE) ||
+                                eReference.equals(ProblemPackage.Literals.PARAMETER__PARAMETER_TYPE) ||
+                                eReference.equals(ProblemPackage.Literals.TYPE_SCOPE__TARGET_TYPE)) {
+                        if (builtinSymbols.exists().equals(candidateEObjectOrProxy)) {
+                                return false;
+                        }
+                        var arity = candidate.getUserData(ProblemResourceDescriptionStrategy.ARITY);
+                        return arity == null || arity.equals("1");
+                }
+
+                if (eReference.equals(ProblemPackage.Literals.CLASS_DECLARATION__SUPER_TYPES)) {
+                        return supertypeShouldBeVisible(candidate, context, builtinSymbols, candidateEObjectOrProxy);
+                }
+
+                return true;
+        }
+
+        private boolean supertypeShouldBeVisible(IEObjectDescription candidate, ContentAssistContext context,
+                                                                                         BuiltinSymbols builtinSymbols, EObject candidateEObjectOrProxy) {
+                if (!ProblemPackage.Literals.CLASS_DECLARATION.isSuperTypeOf(candidate.getEClass()) ||
+                                builtinSymbols.node().equals(candidateEObjectOrProxy) ||
+                                builtinSymbols.contained().equals(candidateEObjectOrProxy)) {
+                        return false;
+                }
+                if (context.getCurrentModel() instanceof ClassDeclaration classDeclaration &&
+                                candidateEObjectOrProxy instanceof ClassDeclaration candidateClassDeclaration) {
+                        return !classDeclaration.equals(candidateClassDeclaration) &&
+                                        !classDeclaration.getSuperTypes().contains(candidateClassDeclaration);
+                }
+                return true;
+        }
+
+        @Nullable
+        private EReference getEReference(CrossReference crossReference) {
+                var type = currentTypeFinder.findCurrentTypeAfter(crossReference);
+                if (!(type instanceof EClass eClass)) {
+                        return null;
+                }
+                return GrammarUtil.getReference(crossReference, eClass);
         }
 
         protected EObject getCurrentValue(CrossReference crossRef, ContentAssistContext context) {
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
index b3c58366..ecaa7e0d 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
@@ -63,6 +63,8 @@ public class ModelInitializer {
 
         private final Map<PartialRelation, RelationInfo> partialRelationInfoMap = new HashMap<>();
 
+        private final Set<PartialRelation> targetTypes = new HashSet<>();
+
         private final MetamodelBuilder metamodelBuilder = Metamodel.builder();
 
         private Metamodel metamodel;
@@ -285,6 +287,7 @@ public class ModelInitializer {
                 var relation = getPartialRelation(referenceDeclaration);
                 var source = getPartialRelation(classDeclaration);
                 var target = getPartialRelation(referenceDeclaration.getReferenceType());
+                targetTypes.add(target);
                 boolean containment = referenceDeclaration.getKind() == ReferenceKind.CONTAINMENT;
                 var opposite = referenceDeclaration.getOpposite();
                 PartialRelation oppositeRelation = null;
@@ -473,17 +476,16 @@ public class ModelInitializer {
         private void collectPredicateDefinition(PredicateDefinition predicateDefinition, ModelStoreBuilder storeBuilder) {
                 var partialRelation = getPartialRelation(predicateDefinition);
                 var query = toQuery(partialRelation.name(), predicateDefinition);
-                boolean mutable;
+                boolean mutable = targetTypes.contains(partialRelation);
                 TruthValue defaultValue;
                 if (predicateDefinition.isError()) {
-                        mutable = false;
                         defaultValue = TruthValue.FALSE;
                 } else {
                         var seed = modelSeed.getSeed(partialRelation);
                         defaultValue = seed.reducedValue() == TruthValue.FALSE ? TruthValue.FALSE : TruthValue.UNKNOWN;
                         var cursor = seed.getCursor(defaultValue, problemTrace.getNodeTrace().size());
                         // The symbol should be mutable if there is at least one non-default entry in the seed.
-                        mutable = cursor.move();
+                        mutable = mutable || cursor.move();
                 }
                 var translator = new PredicateTranslator(partialRelation, query, mutable, defaultValue);
                 storeBuilder.with(translator);
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
index 899e3cb3..b4abce81 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/ModelGenerationTest.java
@@ -77,7 +77,7 @@ class ModelGenerationTest {
                                 % Scope
                                 scope Post = 5, Person = 5.
                                 """);
-                assertThat(parsedProblem.errors(), empty());
+                assertThat(parsedProblem.getResourceErrors(), empty());
                 var problem = parsedProblem.problem();
 
                 var storeBuilder = ModelStore.builder()
@@ -211,7 +211,7 @@ class ModelGenerationTest {
 
                                 scope node = 200..210, Region = 10..*, Choice = 1..*, Statechart = 1.
                                 """);
-                assertThat(parsedProblem.errors(), empty());
+                assertThat(parsedProblem.getResourceErrors(), empty());
                 var problem = parsedProblem.problem();
 
                 var storeBuilder = ModelStore.builder()
@@ -278,7 +278,7 @@ class ModelGenerationTest {
 
                                 scope Filesystem += 0, Entry = 100.
                                 """);
-                assertThat(parsedProblem.errors(), empty());
+                assertThat(parsedProblem.getResourceErrors(), empty());
                 var problem = parsedProblem.problem();
 
                 var storeBuilder = ModelStore.builder()
diff --git a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
index 0a91178b..0fb96954 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -40,10 +40,13 @@ enum ReferenceKind:
 ReferenceDeclaration:
         (referenceType=[Relation|NonContainmentQualifiedName] |
         kind=ReferenceKind referenceType=[Relation|QualifiedName])
-        ("[" multiplicity=Multiplicity "]")?
+        (multiplicity=ReferenceMultiplicity)?
         name=Identifier
         ("opposite" opposite=[ReferenceDeclaration|QualifiedName])?;
 
+ReferenceMultiplicity returns Multiplicity:
+        "[" Multiplicity "]";
+
 //enum PrimitiveType:
 //      INT="int" | REAL="real" | STRING="string";
 //
diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
index 2636a8ee..0a5cb3c2 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemRuntimeModule.java
@@ -12,6 +12,7 @@ package tools.refinery.language;
 import com.google.inject.Binder;
 import com.google.inject.name.Names;
 import org.eclipse.xtext.conversion.IValueConverterService;
+import org.eclipse.xtext.linking.ILinkingService;
 import org.eclipse.xtext.naming.IQualifiedNameConverter;
 import org.eclipse.xtext.parser.IParser;
 import org.eclipse.xtext.resource.*;
@@ -19,17 +20,21 @@ import org.eclipse.xtext.scoping.IGlobalScopeProvider;
 import org.eclipse.xtext.scoping.IScopeProvider;
 import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
 import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.validation.IDiagnosticConverter;
 import org.eclipse.xtext.validation.IResourceValidator;
 import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
 import tools.refinery.language.conversion.ProblemValueConverterService;
+import tools.refinery.language.linking.ProblemLinkingService;
 import tools.refinery.language.naming.ProblemQualifiedNameConverter;
 import tools.refinery.language.parser.antlr.TokenSourceInjectingProblemParser;
 import tools.refinery.language.resource.ProblemDerivedStateComputer;
 import tools.refinery.language.resource.ProblemLocationInFileProvider;
+import tools.refinery.language.resource.ProblemResource;
 import tools.refinery.language.resource.ProblemResourceDescriptionStrategy;
 import tools.refinery.language.scoping.ProblemGlobalScopeProvider;
 import tools.refinery.language.scoping.ProblemLocalScopeProvider;
 import tools.refinery.language.serializer.PreferShortAssertionsProblemSemanticSequencer;
+import tools.refinery.language.validation.ProblemDiagnosticConverter;
 
 /**
  * Use this class to register components to be used at runtime / without the
@@ -55,6 +60,11 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         }
 
         @Override
+        public Class<? extends ILinkingService> bindILinkingService() {
+                return ProblemLinkingService.class;
+        }
+
+        @Override
         public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() {
                 return ProblemGlobalScopeProvider.class;
         }
@@ -67,7 +77,7 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
 
         @Override
         public Class<? extends XtextResource> bindXtextResource() {
-                return DerivedStateAwareResource.class;
+                return ProblemResource.class;
         }
 
         // Method name follows Xtext convention.
@@ -93,4 +103,8 @@ public class ProblemRuntimeModule extends AbstractProblemRuntimeModule {
         public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
                 return PreferShortAssertionsProblemSemanticSequencer.class;
         }
+
+        public Class<? extends IDiagnosticConverter> bindIDiagnosticConverter() {
+                return ProblemDiagnosticConverter.class;
+        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/linking/ProblemLinkingService.java b/subprojects/language/src/main/java/tools/refinery/language/linking/ProblemLinkingService.java
new file mode 100644
index 00000000..511ed420
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/linking/ProblemLinkingService.java
@@ -0,0 +1,72 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2018 itemis AG (http://www.itemis.eu) and others.
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.language.linking;
+
+import com.google.inject.Inject;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.xtext.linking.impl.DefaultLinkingService;
+import org.eclipse.xtext.linking.impl.IllegalNodeException;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+import org.eclipse.xtext.naming.QualifiedName;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.resource.IEObjectDescription;
+import org.eclipse.xtext.scoping.IScope;
+
+import java.util.*;
+
+public class ProblemLinkingService extends DefaultLinkingService {
+        @Inject
+        private IQualifiedNameConverter qualifiedNameConverter;
+
+        private static final Logger logger = Logger.getLogger(ProblemLinkingService.class);
+
+        @Override
+        public List<EObject> getLinkedObjects(EObject context, EReference ref, INode node) throws IllegalNodeException {
+                final EClass requiredType = ref.getEReferenceType();
+                if (requiredType == null) {
+                        return List.of();
+                }
+                final String crossRefString = getCrossRefNodeAsString(node);
+                if (crossRefString == null || crossRefString.isEmpty()) {
+                        return List.of();
+                }
+                if (logger.isDebugEnabled()) {
+                        logger.debug("before getLinkedObjects: node: '%s'".formatted(crossRefString));
+                }
+                final IScope scope = getScope(context, ref);
+                if (scope == null) {
+                        throw new AssertionError(("Scope provider must not return null for context %s, reference %s! Consider to" +
+                                        " return IScope.NULLSCOPE instead.").formatted(context, ref));
+                }
+                final QualifiedName qualifiedLinkName = qualifiedNameConverter.toQualifiedName(crossRefString);
+                final Iterator<IEObjectDescription> iterator = scope.getElements(qualifiedLinkName).iterator();
+                StringBuilder debug = null;
+                final Set<EObject> result = new LinkedHashSet<>();
+                if (logger.isDebugEnabled()) {
+                        debug = new StringBuilder()
+                                        .append("after getLinkedObjects: node: '")
+                                        .append(crossRefString)
+                                        .append("' result: ");
+                }
+                while (iterator.hasNext()) {
+                        var eObjectDescription = iterator.next();
+                        if (debug != null) {
+                                debug.append(eObjectDescription).append(", ");
+                        }
+                        result.add(eObjectDescription.getEObjectOrProxy());
+                }
+                if (debug != null) {
+                        logger.debug(debug);
+                }
+                return List.copyOf(result);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java
new file mode 100644
index 00000000..43239ffe
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResource.java
@@ -0,0 +1,263 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2023 itemis AG (http://www.itemis.eu) and others.
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.language.resource;
+
+import com.google.inject.Inject;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.diagnostics.DiagnosticMessage;
+import org.eclipse.xtext.diagnostics.Severity;
+import org.eclipse.xtext.linking.ILinkingDiagnosticMessageProvider;
+import org.eclipse.xtext.linking.impl.IllegalNodeException;
+import org.eclipse.xtext.linking.impl.XtextLinkingDiagnostic;
+import org.eclipse.xtext.linking.lazy.LazyLinkingResource;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.resource.DerivedStateAwareResource;
+import org.eclipse.xtext.util.Triple;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+public class ProblemResource extends DerivedStateAwareResource {
+        private static final Logger log = Logger.getLogger(ProblemResource.class);
+
+        @Inject
+        private ILinkingDiagnosticMessageProvider.Extended linkingDiagnosticMessageProvider;
+
+        /**
+         * Our own version of this field, because the original is not accessible.
+         */
+        private int cyclicLinkingDetectionCounter = 0;
+
+        /**
+         * Tries to resolve a reference and emits a diagnostic if the reference is unresolvable or ambiguous.
+         * <p>
+         * This method was copied from {@link LazyLinkingResource#getEObject(String, Triple)}, but we modified it to also
+         * handle ambiguous references.
+         *
+         * @param uriFragment The URI fragment to resolve.
+         * @param triple      The linking triple.
+         * @return The resolved {@link EObject}.
+         * @throws AssertionError If the URI fragment is unresolvable.
+         */
+        @Override
+        protected EObject getEObject(String uriFragment, Triple<EObject, EReference, INode> triple) throws AssertionError {
+                cyclicLinkingDetectionCounter++;
+                if (cyclicLinkingDetectionCounter > cyclicLinkingDectectionCounterLimit && !resolving.add(triple)) {
+                        return handleCyclicResolution(triple);
+                }
+                try {
+                        Set<String> unresolvableProxies = getUnresolvableURIFragments();
+                        if (unresolvableProxies.contains(uriFragment)) {
+                                return null;
+                        }
+                        var result = doGetEObject(triple);
+                        if (result == null) {
+                                if (isUnresolveableProxyCacheable(triple)) {
+                                        unresolvableProxies.add(uriFragment);
+                                }
+                        } else {
+                                // remove previously added error markers, since everything should be fine now
+                                unresolvableProxies.remove(uriFragment);
+                        }
+                        return result;
+                } catch (IllegalNodeException e) {
+                        createAndAddDiagnostic(triple, e);
+                        return null;
+                } finally {
+                        if (cyclicLinkingDetectionCounter > cyclicLinkingDectectionCounterLimit) {
+                                resolving.remove(triple);
+                        }
+                        cyclicLinkingDetectionCounter--;
+                }
+        }
+
+        @Nullable
+        private EObject doGetEObject(Triple<EObject, EReference, INode> triple) {
+                EReference reference = triple.getSecond();
+                try {
+                        List<EObject> linkedObjects = getLinkingService().getLinkedObjects(triple.getFirst(), reference,
+                                        triple.getThird());
+                        if (linkedObjects.isEmpty()) {
+                                createAndAddDiagnostic(triple);
+                                return null;
+                        }
+                        if (linkedObjects.size() > 1) {
+                                createAndAddAmbiguousReferenceDiagnostic(triple);
+                                return null;
+                        }
+                        EObject result = linkedObjects.get(0);
+                        if (!EcoreUtil2.isAssignableFrom(reference.getEReferenceType(), result.eClass())) {
+                                log.error("An element of type %s is not assignable to the reference %s.%s".formatted(
+                                                result.getClass().getName(), reference.getEContainingClass().getName(), reference.getName()));
+                                createAndAddDiagnostic(triple);
+                                return null;
+                        }
+                        removeDiagnostic(triple);
+                        return result;
+                } catch (CyclicLinkingError e) {
+                        if (e.triple.equals(triple)) {
+                                log.error(e.getMessage(), e);
+                                createAndAddDiagnostic(triple);
+                                return null;
+                        } else {
+                                throw e;
+                        }
+                }
+        }
+
+        @Override
+        protected EObject handleCyclicResolution(Triple<EObject, EReference, INode> triple) throws AssertionError {
+                // Throw our own version of {@link LazyLinkingResource.CyclicLinkingException}.
+                throw new CyclicLinkingError("Cyclic resolution of lazy links : %s in resource '%s'.".formatted(
+                                getReferences(triple, resolving), getURI()), triple);
+        }
+
+        @Override
+        protected void createAndAddDiagnostic(Triple<EObject, EReference, INode> triple) {
+                if (isValidationDisabled()) {
+                        return;
+                }
+                DiagnosticMessage message = createDiagnosticMessage(triple);
+                addOrReplaceDiagnostic(triple, message);
+        }
+
+        @Override
+        protected void createAndAddDiagnostic(Triple<EObject, EReference, INode> triple, IllegalNodeException ex) {
+                if (isValidationDisabled()) {
+                        return;
+                }
+                ILinkingDiagnosticMessageProvider.ILinkingDiagnosticContext context = createDiagnosticMessageContext(triple);
+                DiagnosticMessage message = linkingDiagnosticMessageProvider.getIllegalNodeMessage(context, ex);
+                addOrReplaceDiagnostic(triple, message);
+        }
+
+        protected void createAndAddAmbiguousReferenceDiagnostic(Triple<EObject, EReference, INode> triple) {
+                if (isValidationDisabled()) {
+                        return;
+                }
+                var context = createDiagnosticMessageContext(triple);
+                var typeName = context.getReference().getEReferenceType().getName();
+                String linkText = "";
+                try {
+                        linkText = context.getLinkText();
+                } catch (IllegalNodeException e) {
+                        linkText = e.getNode().getText();
+                }
+                var messageString = "Ambiguous reference to %s '%s'.".formatted(typeName, linkText);
+                var message = new DiagnosticMessage(messageString, Severity.ERROR,
+                                org.eclipse.xtext.diagnostics.Diagnostic.LINKING_DIAGNOSTIC);
+                addOrReplaceDiagnostic(triple, message);
+        }
+
+        /**
+         * Adds a diagnostic message while maintaining the invariant that at most one
+         * {@link ProblemResourceLinkingDiagnostic} is added to the {@link #getErrors()} list.
+         *
+         * @param triple  The triple to add the diagnostic for.
+         * @param message The diagnostic message. Must have {@link Severity#ERROR}.
+         */
+        protected void addOrReplaceDiagnostic(Triple<EObject, EReference, INode> triple, DiagnosticMessage message) {
+                if (message == null) {
+                        return;
+                }
+                if (message.getSeverity() != Severity.ERROR) {
+                        throw new IllegalArgumentException("Only linking diagnostics of ERROR severity are supported");
+                }
+                var list = getDiagnosticList(message);
+                var iterator = list.iterator();
+                while (iterator.hasNext()) {
+                        var diagnostic = iterator.next();
+                        if (diagnostic instanceof ProblemResourceLinkingDiagnostic linkingDiagnostic &&
+                                        linkingDiagnostic.matchesNode(triple.getThird())) {
+                                if (linkingDiagnostic.matchesMessage(message)) {
+                                        return;
+                                }
+                                iterator.remove();
+                                break;
+                        }
+                }
+                var diagnostic = createDiagnostic(triple, message);
+                list.add(diagnostic);
+        }
+
+        /**
+         * Removes the {@link ProblemResourceLinkingDiagnostic} corresponding to the given node, if prevesent, from the
+         * {@link #getErrors()} list.
+         *
+         * @param triple The triple to add the diagnostic for.
+         */
+        @Override
+        protected void removeDiagnostic(Triple<EObject, EReference, INode> triple) {
+                if (getErrors().isEmpty()) {
+                        return;
+                }
+                var list = getErrors();
+                if (list.isEmpty()) {
+                        return;
+                }
+                var iterator = list.iterator();
+                while (iterator.hasNext()) {
+                        var diagnostic = iterator.next();
+                        if (diagnostic instanceof ProblemResourceLinkingDiagnostic linkingDiagnostic &&
+                                        linkingDiagnostic.matchesNode(triple.getThird())) {
+                                iterator.remove();
+                                return;
+                        }
+                }
+        }
+
+        @Override
+        protected Diagnostic createDiagnostic(Triple<EObject, EReference, INode> triple, DiagnosticMessage message) {
+                return new ProblemResourceLinkingDiagnostic(triple.getThird(), message.getMessage(),
+                                message.getIssueCode(), message.getIssueData());
+        }
+
+        /**
+         * Our own version of {@link LazyLinkingResource.CyclicLinkingException}, because the {@code tripe} field in the
+         * original one is not accessible.
+         * <p>
+         * Renamed from {@code CyclicLinkingException} to satisfy naming conventions enforced by Sonar.
+         */
+        public static final class CyclicLinkingError extends AssertionError {
+                private final transient Triple<EObject, EReference, INode> triple;
+
+                private CyclicLinkingError(Object detailMessage, Triple<EObject, EReference, INode> triple) {
+                        super(detailMessage);
+                        this.triple = triple;
+                }
+        }
+
+        /**
+         * Marks all diagnostics inserted by {@link ProblemResource} with a common superclass so that they can
+         * later be removed.
+         * <p>
+         * We have to inherit from {@link XtextLinkingDiagnostic} to access the protected function {@link #getNode()}.
+         */
+        protected static class ProblemResourceLinkingDiagnostic extends XtextLinkingDiagnostic {
+                public ProblemResourceLinkingDiagnostic(INode node, String message, String code, String... data) {
+                        super(node, message, code, data);
+                }
+
+                public boolean matchesNode(INode node) {
+                        return Objects.equals(getNode(), node);
+                }
+
+                public boolean matchesMessage(DiagnosticMessage message) {
+                        return Objects.equals(getMessage(), message.getMessage()) &&
+                                        Objects.equals(getCode(), message.getIssueCode()) &&
+                                        Arrays.equals(getData(), message.getIssueData());
+                }
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
index a16f77eb..cac1f265 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/resource/ProblemResourceDescriptionStrategy.java
@@ -24,8 +24,9 @@ import java.util.Map;
 
 @Singleton
 public class ProblemResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy {
-        public static final String ERROR_PREDICATE = "tools.refinery.language.resource" +
-                        ".ProblemResourceDescriptionStrategy.ERROR_PREDICATE";
+        private static final String DATA_PREFIX = "tools.refinery.language.resource.ProblemResourceDescriptionStrategy.";
+        public static final String ARITY = DATA_PREFIX + "ARITY";
+        public static final String ERROR_PREDICATE = DATA_PREFIX + "ERROR_PREDICATE";
         public static final String ERROR_PREDICATE_TRUE = "true";
 
         @Inject
@@ -97,6 +98,10 @@ public class ProblemResourceDescriptionStrategy extends DefaultResourceDescripti
 
         protected Map<String, String> getUserData(EObject eObject) {
                 var builder = ImmutableMap.<String, String>builder();
+                if (eObject instanceof Relation relation) {
+                        int arity = ProblemUtil.getArity(relation);
+                        builder.put(ARITY, Integer.toString(arity));
+                }
                 if (eObject instanceof PredicateDefinition predicateDefinition && predicateDefinition.isError()) {
                         builder.put(ERROR_PREDICATE, ERROR_PREDICATE_TRUE);
                 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java
index cf099aba..a4437ba6 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/scoping/ProblemScopeProvider.java
@@ -44,7 +44,7 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
                         return getVariableScope(context, scope);
                 }
                 if (reference == ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE) {
-                        return getOppositeScope(context, scope);
+                        return getOppositeScope(context);
                 }
                 return scope;
         }
@@ -96,16 +96,19 @@ public class ProblemScopeProvider extends AbstractProblemScopeProvider {
                 }
         }
 
-        protected IScope getOppositeScope(EObject context, IScope delegateScope) {
+        protected IScope getOppositeScope(EObject context) {
                 var referenceDeclaration = EcoreUtil2.getContainerOfType(context, ReferenceDeclaration.class);
                 if (referenceDeclaration == null) {
-                        return delegateScope;
+                        return IScope.NULLSCOPE;
                 }
                 var relation = referenceDeclaration.getReferenceType();
                 if (!(relation instanceof ClassDeclaration classDeclaration)) {
-                        return delegateScope;
+                        return IScope.NULLSCOPE;
                 }
-                var referenceDeclarations = desugarer.getAllReferenceDeclarations(classDeclaration);
-                return Scopes.scopeFor(referenceDeclarations, delegateScope);
+                var referenceDeclarations = classDeclaration.getFeatureDeclarations()
+                                .stream()
+                                .filter(ReferenceDeclaration.class::isInstance)
+                                .toList();
+                return Scopes.scopeFor(referenceDeclarations);
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
index a9efc4bb..7b6407e1 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/ProblemUtil.java
@@ -7,11 +7,12 @@ package tools.refinery.language.utils;
 
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.util.EcoreUtil;
 import tools.refinery.language.model.problem.*;
 
 public final class ProblemUtil {
         public static final String BUILTIN_LIBRARY_NAME = "builtin";
-        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME);
+        public static final URI BUILTIN_LIBRARY_URI = getLibraryUri();
 
         private ProblemUtil() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
@@ -83,8 +84,44 @@ public final class ProblemUtil {
                 return true;
         }
 
-        private static URI getLibraryUri(String libraryName) {
-                return URI.createURI(ProblemUtil.class.getClassLoader()
-                                .getResource("tools/refinery/language/%s.problem".formatted(libraryName)).toString());
+        public static int getArity(Relation relation) {
+                if (relation instanceof ClassDeclaration || relation instanceof EnumDeclaration) {
+                        return 1;
+                }
+                if (relation instanceof ReferenceDeclaration) {
+                        return 2;
+                }
+                if (relation instanceof PredicateDefinition predicateDefinition) {
+                        return predicateDefinition.getParameters().size();
+                }
+                throw new IllegalArgumentException("Unknown Relation: " + relation);
+        }
+
+        public static boolean isContainerReference(ReferenceDeclaration referenceDeclaration) {
+                var kind = referenceDeclaration.getKind();
+                if (kind == null) {
+                        return false;
+                }
+                return switch (kind) {
+                        case CONTAINMENT -> false;
+                        case CONTAINER -> true;
+                        case REFERENCE -> {
+                                var opposite = referenceDeclaration.getOpposite();
+                                if (opposite == null) {
+                                        yield false;
+                                }
+                                opposite = (ReferenceDeclaration) EcoreUtil.resolve(opposite, referenceDeclaration);
+                                yield opposite.getKind() == ReferenceKind.CONTAINMENT;
+                        }
+                };
+        }
+
+        private static URI getLibraryUri() {
+                var libraryResource = ProblemUtil.class.getClassLoader()
+                                .getResource("tools/refinery/language/%s.problem".formatted(BUILTIN_LIBRARY_NAME));
+                if (libraryResource == null) {
+                        throw new AssertionError("Library '%s' was not found".formatted(BUILTIN_LIBRARY_NAME));
+                }
+                return URI.createURI(libraryResource.toString());
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemDiagnosticConverter.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemDiagnosticConverter.java
new file mode 100644
index 00000000..0b7cc315
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemDiagnosticConverter.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.xtext.validation.DiagnosticConverterImpl;
+import tools.refinery.language.model.problem.Multiplicity;
+import tools.refinery.language.model.problem.ReferenceDeclaration;
+import tools.refinery.language.services.ProblemGrammarAccess;
+
+public class ProblemDiagnosticConverter extends DiagnosticConverterImpl {
+        @Inject
+        private ProblemGrammarAccess grammarAccess;
+
+        @Override
+        protected IssueLocation getLocationData(EObject obj, EStructuralFeature structuralFeature, int index) {
+                if (structuralFeature == null && obj instanceof Multiplicity &&
+                                obj.eContainer() instanceof ReferenceDeclaration referenceDeclaration) {
+                        // Include the enclosing {@code []} square braces in the error location.
+                        // This lets use have a non-0 length error marker for invalid container references such as
+                        // {@code container Foo[] foo opposite bar}, where unbounded multiplicities are disallowed.
+                        return getLocationData(referenceDeclaration, obj.eContainingFeature());
+                }
+                return super.getLocationData(obj, structuralFeature, index);
+        }
+}
diff --git a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
index 88d50c5b..8bda4b95 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ProblemValidator.java
@@ -9,15 +9,21 @@
  */
 package tools.refinery.language.validation;
 
+import com.google.inject.Inject;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
 import org.eclipse.xtext.EcoreUtil2;
 import org.eclipse.xtext.validation.Check;
-
-import com.google.inject.Inject;
-
+import org.jetbrains.annotations.Nullable;
 import tools.refinery.language.model.problem.*;
-import tools.refinery.language.resource.ReferenceCounter;
+import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
 
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
 /**
  * This class contains custom validation rules.
  * <p>
@@ -29,13 +35,38 @@ public class ProblemValidator extends AbstractProblemValidator {
 
         public static final String SINGLETON_VARIABLE_ISSUE = ISSUE_PREFIX + "SINGLETON_VARIABLE";
 
-        public static final String NON_INDIVIDUAL_NODE_ISSUE = ISSUE_PREFIX + "NON_INDIVIDUAL_NODE";
+        public static final String NODE_CONSTANT_ISSUE = ISSUE_PREFIX + "NODE_CONSTANT_ISSUE";
+
+        public static final String DUPLICATE_NAME_ISSUE = ISSUE_PREFIX + "DUPLICATE_NAME";
+
+        public static final String INVALID_MULTIPLICITY_ISSUE = ISSUE_PREFIX + "INVALID_MULTIPLICITY";
+
+        public static final String ZERO_MULTIPLICITY_ISSUE = ISSUE_PREFIX + "ZERO_MULTIPLICITY";
+
+        public static final String MISSING_OPPOSITE_ISSUE = ISSUE_PREFIX + "MISSING_OPPOSITE";
+
+        public static final String INVALID_OPPOSITE_ISSUE = ISSUE_PREFIX + "INVALID_OPPOSITE";
+
+        public static final String INVALID_SUPERTYPE_ISSUE = ISSUE_PREFIX + "INVALID_SUPERTYPE";
+
+        public static final String INVALID_REFERENCE_TYPE_ISSUE = ISSUE_PREFIX + "INVALID_REFERENCE_TYPE";
+
+        public static final String INVALID_ARITY_ISSUE = ISSUE_PREFIX + "INVALID_ARITY";
+
+        public static final String INVALID_TRANSITIVE_CLOSURE_ISSUE = ISSUE_PREFIX + "INVALID_TRANSITIVE_CLOSURE";
+
+        public static final String INVALID_VALUE_ISSUE = ISSUE_PREFIX + "INVALID_VALUE";
+
+        public static final String UNSUPPORTED_ASSERTION_ISSUE = ISSUE_PREFIX + "UNSUPPORTED_ASSERTION";
 
         @Inject
         private ReferenceCounter referenceCounter;
 
+        @Inject
+        private ProblemDesugarer desugarer;
+
         @Check
-        public void checkUniqueVariable(VariableOrNodeExpr expr) {
+        public void checkSingletonVariable(VariableOrNodeExpr expr) {
                 var variableOrNode = expr.getVariableOrNode();
                 if (variableOrNode instanceof Variable variable && ProblemUtil.isImplicitVariable(variable)
                                 && !ProblemUtil.isSingletonVariable(variable)) {
@@ -51,14 +82,325 @@ public class ProblemValidator extends AbstractProblemValidator {
         }
 
         @Check
-        public void checkNonUniqueNode(VariableOrNodeExpr expr) {
+        public void checkNodeConstants(VariableOrNodeExpr expr) {
                 var variableOrNode = expr.getVariableOrNode();
                 if (variableOrNode instanceof Node node && !ProblemUtil.isIndividualNode(node)) {
                         var name = node.getName();
-                        var message = ("Only individual nodes can be referenced in predicates. " +
+                        var message = ("Only individuals can be referenced in predicates. " +
                                         "Mark '%s' as individual with the declaration 'indiv %s.'").formatted(name, name);
                         error(message, expr, ProblemPackage.Literals.VARIABLE_OR_NODE_EXPR__VARIABLE_OR_NODE,
-                                        INSIGNIFICANT_INDEX, NON_INDIVIDUAL_NODE_ISSUE);
+                                        INSIGNIFICANT_INDEX, NODE_CONSTANT_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkUniqueDeclarations(Problem problem) {
+                var relations = new ArrayList<Relation>();
+                var individuals = new ArrayList<Node>();
+                for (var statement : problem.getStatements()) {
+                        if (statement instanceof Relation relation) {
+                                relations.add(relation);
+                        } else if (statement instanceof IndividualDeclaration individualDeclaration) {
+                                individuals.addAll(individualDeclaration.getNodes());
+                        }
+                }
+                checkUniqueSimpleNames(relations);
+                checkUniqueSimpleNames(individuals);
+        }
+
+        @Check
+        public void checkUniqueFeatures(ClassDeclaration classDeclaration) {
+                checkUniqueSimpleNames(classDeclaration.getFeatureDeclarations());
+        }
+
+        @Check
+        public void checkUniqueLiterals(EnumDeclaration enumDeclaration) {
+                checkUniqueSimpleNames(enumDeclaration.getLiterals());
+        }
+
+        protected void checkUniqueSimpleNames(Iterable<? extends NamedElement> namedElements) {
+                var names = new LinkedHashMap<String, Set<NamedElement>>();
+                for (var namedElement : namedElements) {
+                        var name = namedElement.getName();
+                        var objectsWithName = names.computeIfAbsent(name, ignored -> new LinkedHashSet<>());
+                        objectsWithName.add(namedElement);
+                }
+                for (var entry : names.entrySet()) {
+                        var objectsWithName = entry.getValue();
+                        if (objectsWithName.size() <= 1) {
+                                continue;
+                        }
+                        var name = entry.getKey();
+                        var message = "Duplicate name '%s'.".formatted(name);
+                        for (var namedElement : objectsWithName) {
+                                acceptError(message, namedElement, ProblemPackage.Literals.NAMED_ELEMENT__NAME, 0,
+                                                DUPLICATE_NAME_ISSUE);
+                        }
+                }
+        }
+
+        @Check
+        public void checkRangeMultiplicity(RangeMultiplicity rangeMultiplicity) {
+                int lower = rangeMultiplicity.getLowerBound();
+                int upper = rangeMultiplicity.getUpperBound();
+                if (upper >= 0 && lower > upper) {
+                        var message = "Multiplicity range [%d..%d] is inconsistent.";
+                        acceptError(message, rangeMultiplicity, null, 0, INVALID_MULTIPLICITY_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkReferenceMultiplicity(ReferenceDeclaration referenceDeclaration) {
+                var multiplicity = referenceDeclaration.getMultiplicity();
+                if (multiplicity == null) {
+                        return;
+                }
+                if (ProblemUtil.isContainerReference(referenceDeclaration) && (
+                                !(multiplicity instanceof RangeMultiplicity rangeMultiplicity) ||
+                                                rangeMultiplicity.getLowerBound() != 0 ||
+                                                rangeMultiplicity.getUpperBound() != 1)) {
+                        var message = "The only allowed multiplicity for container references is [0..1]";
+                        acceptError(message, multiplicity, null, 0, INVALID_MULTIPLICITY_ISSUE);
+                }
+                if ((multiplicity instanceof ExactMultiplicity exactMultiplicity &&
+                                exactMultiplicity.getExactValue() == 0) ||
+                                (multiplicity instanceof RangeMultiplicity rangeMultiplicity &&
+                                                rangeMultiplicity.getLowerBound() == 0 &&
+                                                rangeMultiplicity.getUpperBound() == 0)) {
+                        var message = "The multiplicity constraint does not allow any reference links";
+                        acceptWarning(message, multiplicity, null, 0, ZERO_MULTIPLICITY_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkOpposite(ReferenceDeclaration referenceDeclaration) {
+                var opposite = referenceDeclaration.getOpposite();
+                if (opposite == null || opposite.eIsProxy()) {
+                        return;
+                }
+                var oppositeOfOpposite = opposite.getOpposite();
+                if (oppositeOfOpposite == null) {
+                        acceptError("Reference '%s' does not declare '%s' as an opposite."
+                                                        .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                        referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                        INVALID_OPPOSITE_ISSUE);
+                        var oppositeResource = opposite.eResource();
+                        if (oppositeResource != null && oppositeResource.equals(referenceDeclaration.eResource())) {
+                                acceptError("Missing opposite '%s' for reference '%s'."
+                                                                .formatted(referenceDeclaration.getName(), opposite.getName()),
+                                                opposite, ProblemPackage.Literals.NAMED_ELEMENT__NAME, 0, MISSING_OPPOSITE_ISSUE);
+                        }
+                        return;
+                }
+                if (!referenceDeclaration.equals(oppositeOfOpposite)) {
+                        var messageBuilder = new StringBuilder()
+                                        .append("Expected reference '")
+                                        .append(opposite.getName())
+                                        .append("' to have opposite '")
+                                        .append(referenceDeclaration.getName())
+                                        .append("'");
+                        var oppositeOfOppositeName = oppositeOfOpposite.getName();
+                        if (oppositeOfOppositeName != null) {
+                                messageBuilder.append(", got '")
+                                                .append(oppositeOfOppositeName)
+                                                .append("' instead");
+                        }
+                        messageBuilder.append(".");
+                        acceptError(messageBuilder.toString(), referenceDeclaration,
+                                        ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0, INVALID_OPPOSITE_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkContainerOpposite(ReferenceDeclaration referenceDeclaration) {
+                var kind = referenceDeclaration.getKind();
+                var opposite = referenceDeclaration.getOpposite();
+                if (opposite != null && opposite.eIsProxy()) {
+                        // If {@code opposite} is a proxy, we have already emitted a linker error.
+                        return;
+                }
+                if (kind == ReferenceKind.CONTAINMENT) {
+                        if (opposite != null && opposite.getKind() == ReferenceKind.CONTAINMENT) {
+                                acceptError("Opposite '%s' of containment reference '%s' is not a container reference."
+                                                                .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                                referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                                INVALID_OPPOSITE_ISSUE);
+                        }
+                } else if (kind == ReferenceKind.CONTAINER) {
+                        if (opposite == null) {
+                                acceptError("Container reference '%s' requires an opposite.".formatted(referenceDeclaration.getName()),
+                                                referenceDeclaration, ProblemPackage.Literals.NAMED_ELEMENT__NAME, 0, MISSING_OPPOSITE_ISSUE);
+                        } else if (opposite.getKind() != ReferenceKind.CONTAINMENT) {
+                                acceptError("Opposite '%s' of container reference '%s' is not a containment reference."
+                                                                .formatted(opposite.getName(), referenceDeclaration.getName()),
+                                                referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__OPPOSITE, 0,
+                                                INVALID_OPPOSITE_ISSUE);
+                        }
+                }
+        }
+
+        @Check
+        public void checkSupertypes(ClassDeclaration classDeclaration) {
+                var supertypes = classDeclaration.getSuperTypes();
+                int supertypeCount = supertypes.size();
+                for (int i = 0; i < supertypeCount; i++) {
+                        var supertype = supertypes.get(i);
+                        if (!supertype.eIsProxy() && !(supertype instanceof ClassDeclaration)) {
+                                var message = "Supertype '%s' of '%s' is not a class."
+                                                .formatted(supertype.getName(), classDeclaration.getName());
+                                acceptError(message, classDeclaration, ProblemPackage.Literals.CLASS_DECLARATION__SUPER_TYPES, i,
+                                                INVALID_SUPERTYPE_ISSUE);
+                        }
+                }
+        }
+
+        @Check
+        public void checkReferenceType(ReferenceDeclaration referenceDeclaration) {
+                if (referenceDeclaration.getKind() == ReferenceKind.REFERENCE &&
+                                !ProblemUtil.isContainerReference(referenceDeclaration)) {
+                        checkArity(referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__REFERENCE_TYPE, 1);
+                        return;
+                }
+                var referenceType = referenceDeclaration.getReferenceType();
+                if (referenceType == null || referenceType.eIsProxy() || referenceType instanceof ClassDeclaration) {
+                        // Either correct, or a missing reference type where we are probably already emitting another error.
+                        return;
+                }
+                var message = "Reference type '%s' of the containment or container reference '%s' is not a class."
+                                .formatted(referenceType.getName(), referenceDeclaration.getName());
+                acceptError(message, referenceDeclaration, ProblemPackage.Literals.REFERENCE_DECLARATION__REFERENCE_TYPE, 0,
+                                INVALID_REFERENCE_TYPE_ISSUE);
+        }
+
+        @Check
+        public void checkParameterType(Parameter parameter) {
+                checkArity(parameter, ProblemPackage.Literals.PARAMETER__PARAMETER_TYPE, 1);
+        }
+
+        @Check
+        public void checkAtom(Atom atom) {
+                int argumentCount = atom.getArguments().size();
+                checkArity(atom, ProblemPackage.Literals.ATOM__RELATION, argumentCount);
+                if (atom.isTransitiveClosure() && argumentCount != 2) {
+                        var message = "Transitive closure needs exactly 2 arguments, got %d arguments instead."
+                                        .formatted(argumentCount);
+                        acceptError(message, atom, ProblemPackage.Literals.ATOM__TRANSITIVE_CLOSURE, 0,
+                                        INVALID_TRANSITIVE_CLOSURE_ISSUE);
+                }
+        }
+
+        @Check
+        public void checkAssertion(Assertion assertion) {
+                int argumentCount = assertion.getArguments().size();
+                if (!(assertion.getValue() instanceof LogicConstant)) {
+                        var message = "Assertion value must be one of 'true', 'false', 'unknown', or 'error'.";
+                        acceptError(message, assertion, ProblemPackage.Literals.ASSERTION__VALUE, 0, INVALID_VALUE_ISSUE);
+                }
+                checkArity(assertion, ProblemPackage.Literals.ASSERTION__RELATION, argumentCount);
+        }
+
+        @Check
+        public void checkTypeScope(TypeScope typeScope) {
+                checkArity(typeScope, ProblemPackage.Literals.TYPE_SCOPE__TARGET_TYPE, 1);
+        }
+
+        private void checkArity(EObject eObject, EReference reference, int expectedArity) {
+                var value = eObject.eGet(reference);
+                if (!(value instanceof Relation relation) || relation.eIsProxy()) {
+                        // Feature does not point to a {@link Relation}, we are probably already emitting another error.
+                        return;
+                }
+                int arity = ProblemUtil.getArity(relation);
+                if (arity == expectedArity) {
+                        return;
+                }
+                var message = "Expected symbol '%s' to have arity %d, got arity %d instead."
+                                .formatted(relation.getName(), expectedArity, arity);
+                acceptError(message, eObject, reference, 0, INVALID_ARITY_ISSUE);
+        }
+
+        @Check
+        public void checkMultiObjectAssertion(Assertion assertion) {
+                var builtinSymbolsOption = desugarer.getBuiltinSymbols(assertion);
+                if (builtinSymbolsOption.isEmpty()) {
+                        return;
+                }
+                var builtinSymbols = builtinSymbolsOption.get();
+                var relation = assertion.getRelation();
+                boolean isExists = builtinSymbols.exists().equals(relation);
+                boolean isEquals = builtinSymbols.equals().equals(relation);
+                if ((!isExists && !isEquals) || !(assertion.getValue() instanceof LogicConstant logicConstant)) {
+                        return;
+                }
+                var value = logicConstant.getLogicValue();
+                if (assertion.isDefault()) {
+                        acceptError("Default assertions for 'exists' and 'equals' are not supported.", assertion,
+                                        ProblemPackage.Literals.ASSERTION__DEFAULT, 0, UNSUPPORTED_ASSERTION_ISSUE);
+                        return;
+                }
+                if (value == LogicValue.ERROR) {
+                        acceptError("Error assertions for 'exists' and 'equals' are not supported.", assertion,
+                                        ProblemPackage.Literals.ASSERTION__DEFAULT, 0, UNSUPPORTED_ASSERTION_ISSUE);
+                        return;
+                }
+                if (isExists) {
+                        checkExistsAssertion(assertion, value);
+                        return;
+                }
+                checkEqualsAssertion(assertion, value);
+        }
+
+        private void checkExistsAssertion(Assertion assertion, LogicValue value) {
+                if (value == LogicValue.TRUE || value == LogicValue.UNKNOWN) {
+                        // {@code true} is always a valid value for {@code exists}, while {@code unknown} values may always be
+                        // refined to {@code true} if necessary (e.g., for individual nodes).
+                        return;
+                }
+                var arguments = assertion.getArguments();
+                if (arguments.isEmpty()) {
+                        // We already report an error on invalid arity.
+                        return;
+                }
+                var node = getNodeArgumentForMultiObjectAssertion(arguments.get(0));
+                if (node != null && !node.eIsProxy() && ProblemUtil.isIndividualNode(node)) {
+                        acceptError("Individual nodes must exist.", assertion, null, 0, UNSUPPORTED_ASSERTION_ISSUE);
+                }
+        }
+
+        private void checkEqualsAssertion(Assertion assertion, LogicValue value) {
+                var arguments = assertion.getArguments();
+                if (arguments.size() < 2) {
+                        // We already report an error on invalid arity.
+                        return;
+                }
+                var left = getNodeArgumentForMultiObjectAssertion(arguments.get(0));
+                var right = getNodeArgumentForMultiObjectAssertion(arguments.get(1));
+                if (left == null || left.eIsProxy() || right == null || right.eIsProxy()) {
+                        return;
+                }
+                if (left.equals(right)) {
+                        if (value == LogicValue.FALSE || value == LogicValue.ERROR) {
+                                acceptError("A node cannot be necessarily unequal to itself.", assertion, null, 0,
+                                                UNSUPPORTED_ASSERTION_ISSUE);
+                        }
+                } else {
+                        if (value != LogicValue.FALSE) {
+                                acceptError("Equalities between distinct nodes are not supported.", assertion, null, 0,
+                                                UNSUPPORTED_ASSERTION_ISSUE);
+                        }
+                }
+        }
+
+        @Nullable
+        private Node getNodeArgumentForMultiObjectAssertion(AssertionArgument argument) {
+                if (argument instanceof WildcardAssertionArgument) {
+                        acceptError("Wildcard arguments for 'exists' are not supported.", argument, null, 0,
+                                        UNSUPPORTED_ASSERTION_ISSUE);
+                        return null;
+                }
+                if (argument instanceof NodeAssertionArgument nodeAssertionArgument) {
+                        return nodeAssertionArgument.getNode();
                 }
+                throw new IllegalArgumentException("Unknown assertion argument: " + argument);
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/resource/ReferenceCounter.java b/subprojects/language/src/main/java/tools/refinery/language/validation/ReferenceCounter.java
index f1be55ee..55cbd71d 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/resource/ReferenceCounter.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/validation/ReferenceCounter.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.resource;
+package tools.refinery.language.validation;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
index 96e7cf9c..72d57f54 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/ProblemParsingTest.java
@@ -51,6 +51,6 @@ class ProblemParsingTest {
                                 ?children(bob, ciri).
                                 taxStatus(anne, ADULT).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
         }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java
new file mode 100644
index 00000000..464c207c
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/linking/AmbiguousReferenceTest.java
@@ -0,0 +1,98 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.linking;
+
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.diagnostics.Diagnostic;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class AmbiguousReferenceTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        class Foo {
+                                contains Quux quux
+                        }
+
+                        class Quux.
+
+                        quux(f, q).
+                        """, """
+                        class Foo {
+                                contains Quux quux
+                        }
+
+                        class Quux.
+
+                        pred example(Foo f, Quux q) <-> quux(f, q).
+                        """, """
+                        class Foo {
+                                contains Quux quux opposite foo
+                        }
+
+                        class Bar {
+                                contains Quux quux opposite bar
+                        }
+
+                        class Quux {
+                                container Foo foo opposite quux
+                                container Bar bar opposite quux
+                        }
+                        """})
+        void unambiguousReferenceTest(String text) {
+                var problem = parseHelper.parse(text);
+                assertThat(problem.getResourceErrors(), empty());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        class Foo {
+                                contains Quux quux
+                        }
+
+                        class Bar {
+                                contains Quux quux
+                        }
+
+                        class Quux.
+
+                        quux(f, q).
+                        """, """
+                        class Foo {
+                                contains Quux quux
+                        }
+
+                        class Bar {
+                                contains Quux quux
+                        }
+
+                        class Quux.
+
+                        pred example(Foo f, Quuq q) <-> quux(f, q).
+                        """})
+        void ambiguousReferenceTest(String text) {
+                var problem = parseHelper.parse(text);
+                var errors = problem.getResourceErrors();
+                assertThat(problem.getResourceErrors(), hasItem(allOf(
+                                hasProperty("code", is(Diagnostic.LINKING_DIAGNOSTIC)),
+                                hasProperty("message", containsString("'quux'"))
+                )));
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
index ed193e90..a9c5f62a 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/parser/antlr/TransitiveClosureParserTest.java
@@ -31,7 +31,7 @@ class TransitiveClosureParserTest {
                 var problem = parseHelper.parse("""
                                         pred foo(a, b) <-> a + (b) > 10.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 var literal = problem.pred("foo").conj(0).lit(0).get();
                 assertThat(literal, instanceOf(ComparisonExpr.class));
                 var left = ((ComparisonExpr) literal).getLeft();
@@ -45,7 +45,7 @@ class TransitiveClosureParserTest {
                 var problem = parseHelper.parse("""
                                         pred foo(a, b) <-> equals+(a, b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 var literal = problem.pred("foo").conj(0).lit(0).get();
                 assertThat(literal, instanceOf(Atom.class));
                 var atom = (Atom) literal;
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java
index 68514bfa..56e65550 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/rules/RuleParsingTest.java
@@ -42,7 +42,7 @@ class RuleParsingTest {
                         """ })
         void simpleTest(String text) {
                 var problem = parseHelper.parse(text);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
         }
 
         @Test
@@ -51,7 +51,7 @@ class RuleParsingTest {
                                 pred Person(p).
                                 rule r(p1): must Person(p1) ==> new p2, Person(p2) := unknown.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.rule("r").param(0), equalTo(problem.rule("r").conj(0).lit(0).arg(0).variable()));
                 assertThat(problem.rule("r").consequent(0).action(0).newVar(),
                                 equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(0).variable()));
@@ -63,7 +63,7 @@ class RuleParsingTest {
                                 pred Friend(a, b).
                                 rule r(p1): !may Friend(p1, p2) ==> new p2, Friend(p1, p2) := true.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.rule("r").conj(0).lit(0).negated().arg(1).variable(),
                                 not(equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(1).variable())));
         }
@@ -74,7 +74,7 @@ class RuleParsingTest {
                                 pred Friend(a, b).
                                 rule r(p1, p2): !may Friend(p1, p2) ==> new p2, Friend(p1, p2) := true.
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.rule("r").param(1),
                                 not(equalTo(problem.rule("r").consequent(0).action(1).assertedAtom().arg(1).variable())));
         }
@@ -85,6 +85,6 @@ class RuleParsingTest {
                                 pred Person(p).
                                 rule r(p1): must Friend(p1, p2) ==> delete p2.
                                 """);
-                assertThat(problem.errors(), not(empty()));
+                assertThat(problem.getResourceErrors(), not(empty()));
         }
 }
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
index 734bfcd1..e76d2993 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/scoping/NodeScopingTest.java
@@ -36,7 +36,7 @@ class NodeScopingTest {
                 var problem = parse("""
                                 pred predicate({PARAM}node a).
                                 """, qualifiedNamePrefix);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.pred("predicate").param(0).getParameterType(),
                                 equalTo(problem.builtin().findClass("node").get()));
         }
@@ -48,7 +48,7 @@ class NodeScopingTest {
                                 predicate(a, a).
                                 ?predicate(a, b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), hasItems("a", "b"));
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("a")));
                 assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.node("a")));
@@ -62,7 +62,7 @@ class NodeScopingTest {
                                 pred predicate(node a) <-> node(b).
                                 predicate(b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), hasItems("b"));
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.node("b")));
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.node("b")));
@@ -77,7 +77,7 @@ class NodeScopingTest {
                                 predicate({PARAM}a, {PARAM}a).
                                 ?predicate({PARAM}a, {PARAM}b).
                                 """, qualifiedNamePrefix, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.individualNode("a")));
                 assertThat(problem.assertion(0).arg(1).node(), equalTo(problem.individualNode("a")));
@@ -92,7 +92,7 @@ class NodeScopingTest {
                                 indiv b.
                                 pred predicate(node a) <-> node({PARAM}b).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(), equalTo(problem.individualNode("b")));
         }
@@ -109,7 +109,7 @@ class NodeScopingTest {
                                 pred predicate(node x) <-> node(x).
                                 predicate({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.builtin().findClass("int").get().getNewNode()));
         }
@@ -121,7 +121,7 @@ class NodeScopingTest {
                 var problem = parse("""
                                 pred predicate(node x) <-> node({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.builtin().findClass("int").get().getNewNode()));
@@ -139,7 +139,7 @@ class NodeScopingTest {
                                 pred predicate(node x) <-> node(x).
                                 predicate({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findClass("Foo").get().getNewNode()));
         }
@@ -151,7 +151,7 @@ class NodeScopingTest {
                                 class Foo.
                                 pred predicate(node x) <-> node({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.findClass("Foo").get().getNewNode()));
@@ -169,7 +169,7 @@ class NodeScopingTest {
                                 pred predicate(node x) <-> node(x).
                                 predicate(new).
                                 """);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), hasItems("new"));
                 assertThat(problem.assertion(0).arg(0).node(), not(equalTo(problem.findClass("Foo").get().getNewNode())));
         }
@@ -182,7 +182,7 @@ class NodeScopingTest {
                                 pred predicate(Foo a) <-> node(a).
                                 predicate({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.findEnum("Foo").literal("alpha")));
         }
@@ -194,7 +194,7 @@ class NodeScopingTest {
                                 enum Foo { alpha, beta }
                                 pred predicate(Foo a) <-> node({PARAM}).
                                 """, qualifiedName, namedProblem);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.findEnum("Foo").literal("alpha")));
@@ -214,7 +214,7 @@ class NodeScopingTest {
                                 pred predicate(node a) <-> node(a).
                                 predicate({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.assertion(0).arg(0).node(), equalTo(problem.builtin().findEnum("bool").literal("true")));
         }
@@ -226,7 +226,7 @@ class NodeScopingTest {
                 var problem = parse("""
                                 pred predicate() <-> node({PARAM}).
                                 """, qualifiedName);
-                assertThat(problem.errors(), empty());
+                assertThat(problem.getResourceErrors(), empty());
                 assertThat(problem.nodeNames(), empty());
                 assertThat(problem.pred("predicate").conj(0).lit(0).arg(0).node(),
                                 equalTo(problem.builtin().findEnum("bool").literal("true")));
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/ArityValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/ArityValidationTest.java
new file mode 100644
index 00000000..68e9fa8d
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/ArityValidationTest.java
@@ -0,0 +1,249 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.validation.ProblemValidator;
+
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class ArityValidationTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        pred Foo(node n) <-> false.
+                        """, """
+                        pred Foo(node n, node m) <-> false.
+                        """, """
+                        enum Foo { FOO_A, FOO_B }
+                        """})
+        void invalidSupertypeTest(String supertypeDefinition) {
+                var problem = parseHelper.parse("""
+                                %s
+
+                                class Bar extends Foo.
+                                """.formatted(supertypeDefinition));
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_SUPERTYPE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("Foo", "Bar"))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        class Foo.
+                        """, """
+                        abstract class Foo.
+                        """})
+        void validSupertypeTest(String supertypeDefinition) {
+                var problem = parseHelper.parse("""
+                                %s
+
+                                class Bar extends Foo.
+                                """.formatted(supertypeDefinition));
+                var issues = problem.validate();
+                assertThat(issues, empty());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        foo().
+                        """, """
+                        foo(a1, a2, a3).
+                        """, """
+                        pred bar() <-> foo().
+                        """, """
+                        pred bar(node n) <-> foo(n, n, n).
+                        """, """
+                        pred bar(foo n) <-> false.
+                        """, """
+                        scope foo = 1..10.
+                        """, """
+                        class Bar {
+                                foo[] f
+                        }
+                        """, """
+                        class Bar {
+                                refers foo[] f
+                        }
+                        """})
+        void invalidArityTest(String usage) {
+                var problem = parseHelper.parse("""
+                                pred foo(node a, node b) <-> a != b.
+
+                                %s
+                                """.formatted(usage));
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_ARITY_ISSUE)),
+                                hasProperty("message", containsString("foo"))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        foo(a).
+                        """, """
+                        pred bar(node m) <-> !foo(m).
+                        """, """
+                        pred bar(foo f) <-> true.
+                        """, """
+                        scope foo = 1..10.
+                        """, """
+                        class Bar {
+                                foo[] quux
+                        }
+                        """, """
+                        class Bar {
+                                refers foo[] quux
+                        }
+                        """})
+        void validUnaryArityTest(String supertypeDefinition) {
+                var problem = parseHelper.parse("""
+                                pred foo(node n) <-> false.
+
+                                %s
+                                """.formatted(supertypeDefinition));
+                var issues = problem.validate();
+                assertThat(issues, empty());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        foo(a, b).
+                        """, """
+                        pred bar(node m) <-> !foo(m, m).
+                        """, /* Also test for parameters without any type annotation. */ """
+                        pred bar(m) <-> foo(m, m).
+                        """})
+        void validBinaryArityTest(String supertypeDefinition) {
+                var problem = parseHelper.parse("""
+                                pred foo(node n, node m) <-> false.
+
+                                %s
+                                """.formatted(supertypeDefinition));
+                var issues = problem.validate();
+                assertThat(issues, empty());
+        }
+
+        @Test
+        void notResolvedArityTest() {
+                var problem = parseHelper.parse("""
+                                notResolved(a, b).
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, not(contains(hasProperty("issueCode", is(ProblemValidator.INVALID_ARITY_ISSUE)))));
+        }
+
+        @Test
+        void validTransitiveClosure() {
+                var problem = parseHelper.parse("""
+                                pred foo(node a, node b) <-> false.
+
+                                pred bar(a, b) <-> foo+(a, b).
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, not(contains(hasProperty("issueCode",
+                                is(ProblemValidator.INVALID_TRANSITIVE_CLOSURE_ISSUE)))));
+        }
+
+        @Test
+        void invalidTransitiveClosure() {
+                // 0 and 1 argument transitive closures do not get parsed as transitive closure
+                // due to the ambiguity with the addition operator {@code a + (b)}.
+                var problem = parseHelper.parse("""
+                                pred foo(node a, node b) <-> false.
+
+                                pred bar(node a, node b) <-> foo+(a, b, a).
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_TRANSITIVE_CLOSURE_ISSUE))
+                )));
+        }
+
+        @ParameterizedTest
+        @MethodSource
+        void invalidReferenceTypeTest(String definition, String referenceKind) {
+                var problem = parseHelper.parse("""
+                                %s
+
+                                class Bar {
+                                        %s Foo foo
+                                }
+                                """.formatted(definition, referenceKind));
+                var issues = problem.validate();
+                assertThat(issues, allOf(
+                                hasItem(allOf(
+                                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                                hasProperty("issueCode", is(ProblemValidator.INVALID_REFERENCE_TYPE_ISSUE)),
+                                                hasProperty("message", stringContainsInOrder("Foo", "foo"))
+                                )),
+                                not(hasItem(hasProperty("issueCode", is(ProblemValidator.INVALID_ARITY_ISSUE))))
+                ));
+        }
+
+        static Stream<Arguments> invalidReferenceTypeTest() {
+                return Stream.of(
+                                "pred Foo(node n) <-> true.",
+                                "pred Foo(node n, node m) <-> true.",
+                                "enum Foo { FOO_A, FOO_B }"
+                ).flatMap(definition -> Stream.of(
+                                Arguments.of(definition, "contains"),
+                                Arguments.of(definition, "container")
+                ));
+        }
+
+
+        @ParameterizedTest
+        @MethodSource
+        void validReferenceTypeTest(String definition, String referenceKind) {
+                var problem = parseHelper.parse("""
+                                %s
+
+                                class Bar {
+                                        %s Foo foo
+                                }
+                                """.formatted(definition, referenceKind));
+                var issues = problem.validate();
+                assertThat(issues, not(hasItem(hasProperty("issueCode", anyOf(
+                                is(ProblemValidator.INVALID_REFERENCE_TYPE_ISSUE),
+                                is(ProblemValidator.INVALID_ARITY_ISSUE)
+                )))));
+        }
+
+        static Stream<Arguments> validReferenceTypeTest() {
+                return Stream.of(
+                                "class Foo.",
+                                "abstract class Foo."
+                ).flatMap(definition -> Stream.of(
+                                Arguments.of(definition, "contains"),
+                                Arguments.of(definition, "container")
+                ));
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java
new file mode 100644
index 00000000..82dea31b
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/AssertionValidationTest.java
@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.validation.ProblemValidator;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.is;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class AssertionValidationTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @Test
+        void invalidValueTest() {
+                var problem = parseHelper.parse("""
+                                class Foo.
+
+                                Foo(n): 5.
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.INVALID_VALUE_ISSUE))));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                        "default exists(n).",
+                        "!exists(A).",
+                        "exists(A): error.",
+                        "exists(n): error.",
+                        "!exists(*).",
+                        "exists(*): error.",
+                        "default equals(n, n).",
+                        "equals(n, m).",
+                        "?equals(n, m).",
+                        "equals(n, m): error.",
+                        "equals(A, B).",
+                        "?equals(A, B).",
+                        "equals(A, B): error.",
+                        "!equals(n, n).",
+                        "equals(n, n): error.",
+                        "!equals(A, A).",
+                        "equals(A, A): error.",
+                        "?equals(n, *).",
+                        "?equals(*, m).",
+                        "equals(*, *).",
+                        "!equals(*, *).",
+                        "?equals(*, *).",
+                        "equals(*, *): error."
+        })
+        void invalidMultiObjectTest(String assertion) {
+                var problem = parseHelper.parse("""
+                                enum Bar { A, B }
+
+                                %s
+                                """.formatted(assertion));
+                var issues = problem.validate();
+                assertThat(issues, hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.UNSUPPORTED_ASSERTION_ISSUE))));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                        "exists(A).",
+                        "?exists(A).",
+                        "exists(n).",
+                        "?exists(n).",
+                        "!exists(n).",
+                        "exists(*).",
+                        "?exists(*).",
+                        "exists(Foo::new).",
+                        "?exists(Foo::new).",
+                        "!exists(Foo::new).",
+                        "equals(A, A).",
+                        "?equals(A, A).",
+                        "!equals(A, B).",
+                        "equals(n, n).",
+                        "?equals(n, n).",
+                        "!equals(n, m).",
+                        "equals(Foo::new, Foo::new).",
+                        "?equals(Foo::new, Foo::new)."
+        })
+        void validMultiObjectTest(String assertion) {
+                var problem = parseHelper.parse("""
+                                class Foo.
+
+                                enum Bar { A, B }
+
+                                %s
+                                """.formatted(assertion));
+                var issues = problem.validate();
+                assertThat(issues, not(hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.UNSUPPORTED_ASSERTION_ISSUE)))));
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/MultiplicityValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/MultiplicityValidationTest.java
new file mode 100644
index 00000000..a8bcb1a6
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/MultiplicityValidationTest.java
@@ -0,0 +1,119 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.validation.ProblemValidator;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class MultiplicityValidationTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @ParameterizedTest
+        @ValueSource(strings = {"2..5", "2..2", "2..*", "2", ""})
+        void validReferenceMultiplicityTest(String range) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar[%s] bar
+                                }
+
+                                class Bar.
+                                """.formatted(range));
+                assertThat(problem.validate(), empty());
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"2..5", "2..2", "2..*", "2", "0..0", "0"})
+        void validScopeMultiplicityTest(String range) {
+                var problem = parseHelper.parse("""
+                                class Foo.
+
+                                scope Foo = %s.
+                                """.formatted(range));
+                assertThat(problem.validate(), empty());
+        }
+
+
+        @ParameterizedTest
+        @ValueSource(strings = {"0", "0..0"})
+        void zeroMReferenceMultiplicityTest(String range) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar[%s] bar
+                                }
+
+                                class Bar.
+                                """.formatted(range));
+                assertThat(problem.validate(), hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.WARNING)),
+                                hasProperty("issueCode", is(ProblemValidator.ZERO_MULTIPLICITY_ISSUE))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                        "container Bar bar opposite foo",
+                        "container Bar[0..1] bar opposite foo",
+                        "container Bar bar", // Invalid, but has valid multiplicity.
+                        "container Bar[0..1] bar", // Invalid, but has valid multiplicity.
+                        "Bar bar opposite foo",
+                        "Bar[0..1] bar opposite foo"
+        })
+        void validContainerReference(String referenceText) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        %s
+                                }
+
+                                class Bar {
+                                        contains Foo foo opposite bar
+                                }
+                                """.formatted(referenceText));
+                assertThat(problem.validate(), not(hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.INVALID_MULTIPLICITY_ISSUE)))));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {
+                        "container Bar[1] bar opposite foo",
+                        "container Bar[1..2] bar opposite foo",
+                        "container Bar[] bar opposite foo",
+                        "container Bar[1] bar", // Also otherwise invalid, because the {@code opposite} is missing.
+                        "container Bar[1..2] bar", // Also otherwise invalid, because the {@code opposite} is missing.
+                        "container Bar[] bar", // Also otherwise invalid, because the {@code opposite} is missing.
+                        "Bar[1] bar opposite foo",
+                        "Bar[1..2] bar opposite foo",
+                        "Bar[] bar opposite foo"
+        })
+        void invalidContainerReference(String referenceText) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        %s
+                                }
+
+                                class Bar {
+                                        contains Foo foo opposite bar
+                                }
+                                """.formatted(referenceText));
+                assertThat(problem.validate(), hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_MULTIPLICITY_ISSUE))
+                )));
+        }
+}
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/validation/OppositeValidationTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/OppositeValidationTest.java
new file mode 100644
index 00000000..57602377
--- /dev/null
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/validation/OppositeValidationTest.java
@@ -0,0 +1,209 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.tests.validation;
+
+import com.google.inject.Inject;
+import org.eclipse.emf.common.util.Diagnostic;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.validation.ProblemValidator;
+
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class OppositeValidationTest {
+        @Inject
+        private ProblemParseHelper parseHelper;
+
+        @ParameterizedTest
+        @ValueSource(strings = {"""
+                        class Foo {
+                                Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                contains Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                contains Bar bar opposite foo
+                        }
+
+                        class Bar {
+                                container Foo foo opposite bar
+                        }
+                        """, """
+                        class Foo {
+                                Foo foo[] opposite foo
+                        }
+                        """})
+        void validOppositeTest(String text) {
+                var problem = parseHelper.parse(text);
+                var issues = problem.validate();
+                assertThat(issues, not(hasItems(hasProperty("issueCode", in(Set.of(
+                                ProblemValidator.INVALID_OPPOSITE_ISSUE,
+                                ProblemValidator.MISSING_OPPOSITE_ISSUE
+                ))))));
+        }
+
+        @Test
+        void missingOppositeTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        Foo foo
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItems(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                ), allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.MISSING_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("bar", "foo"))
+                )));
+        }
+
+        @Test
+        void oppositeMismatchTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar bar opposite foo
+                                        Bar quux opposite foo
+                                }
+
+                                class Bar {
+                                        Foo foo opposite bar
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "quux", "bar"))
+                )));
+        }
+
+        @Test
+        void oppositeMismatchProxyTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        Foo foo opposite quux
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", allOf(
+                                                stringContainsInOrder("foo", "bar"),
+                                                not(containsString("null"))
+                                ))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"contains", "container"})
+        void containmentWithProxyOppositeTest(String keyword) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        %s Bar bar opposite foo
+                                }
+
+                                class Bar.
+                                """.formatted(keyword));
+                var issues = problem.validate();
+                assertThat(issues, not(hasItem(hasProperty("issueCode",
+                                is(ProblemValidator.INVALID_OPPOSITE_ISSUE)))));
+        }
+
+        @Test
+        void containmentWithContainmentOppositeTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        contains Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        contains Foo foo opposite bar
+                                }
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItems(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                ), allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                )));
+        }
+
+        @Test
+        void containerWithoutOppositeTest() {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        container Bar bar
+                                }
+
+                                class Bar.
+                                """);
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.MISSING_OPPOSITE_ISSUE)),
+                                hasProperty("message", containsString("bar"))
+                )));
+        }
+
+        @ParameterizedTest
+        @ValueSource(strings = {"Foo foo", "container Foo foo"})
+        void containerInvalidOppositeTest(String reference) {
+                var problem = parseHelper.parse("""
+                                class Foo {
+                                        container Bar bar opposite foo
+                                }
+
+                                class Bar {
+                                        %s opposite bar
+                                }
+                                """.formatted(reference));
+                var issues = problem.validate();
+                assertThat(issues, hasItem(allOf(
+                                hasProperty("severity", is(Diagnostic.ERROR)),
+                                hasProperty("issueCode", is(ProblemValidator.INVALID_OPPOSITE_ISSUE)),
+                                hasProperty("message", stringContainsInOrder("foo", "bar"))
+                )));
+        }
+}
diff --git a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java
index 6f6a87f7..f1535716 100644
--- a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java
+++ b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/ProblemParseHelper.java
@@ -5,23 +5,26 @@
  */
 package tools.refinery.language.model.tests.utils;
 
-import org.eclipse.xtext.testing.util.ParseHelper;
-
 import com.google.inject.Inject;
-
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.xtext.testing.util.ParseHelper;
+import org.eclipse.xtext.validation.IResourceValidator;
 import tools.refinery.language.model.problem.Problem;
 
 public class ProblemParseHelper {
         @Inject
+        private IResourceValidator resourceValidator;
+        @Inject
         private ParseHelper<Problem> parseHelper;
-        
+
         public WrappedProblem parse(String text) {
                 Problem problem;
                 try {
                         problem = parseHelper.parse(text);
                 } catch (Exception e) {
-                        throw new RuntimeException("Unexpected exception while parsing Problem", e);
+                        throw new AssertionError("Unexpected exception while parsing Problem", e);
                 }
+                EcoreUtil.resolveAll(problem);
                 return new WrappedProblem(problem);
         }
 }
diff --git a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java
index e5aa0043..fc51ff57 100644
--- a/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java
+++ b/subprojects/language/src/testFixtures/java/tools/refinery/language/model/tests/utils/WrappedProblem.java
@@ -6,7 +6,7 @@
 package tools.refinery.language.model.tests.utils;
 
 import org.eclipse.emf.ecore.resource.Resource.Diagnostic;
-import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.util.Diagnostician;
 import tools.refinery.language.model.problem.*;
 import tools.refinery.language.utils.BuiltinSymbols;
 import tools.refinery.language.utils.ProblemDesugarer;
@@ -19,11 +19,18 @@ public record WrappedProblem(Problem problem) {
                 return problem;
         }
 
-        public List<Diagnostic> errors() {
-                EcoreUtil.resolveAll(problem);
+        public List<Diagnostic> getResourceErrors() {
                 return problem.eResource().getErrors();
         }
 
+        public List<Diagnostic> getResourceWarnings() {
+                return problem.eResource().getWarnings();
+        }
+
+        public List<org.eclipse.emf.common.util.Diagnostic> validate() {
+                return Diagnostician.INSTANCE.validate(problem).getChildren();
+        }
+
         public WrappedProblem builtin() {
                 return new WrappedProblem(new ProblemDesugarer().getBuiltinProblem(problem).orElseThrow());
         }
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/LowerTypeScopePropagator.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/LowerTypeScopePropagator.java
index 2be92464..702e570f 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/LowerTypeScopePropagator.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/LowerTypeScopePropagator.java
@@ -13,9 +13,12 @@ import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms;
 import tools.refinery.store.reasoning.ReasoningBuilder;
 import tools.refinery.store.reasoning.literal.CountCandidateLowerBoundLiteral;
+import tools.refinery.store.reasoning.literal.CountUpperBoundLiteral;
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
 
 import java.util.Collection;
 import java.util.List;
@@ -39,7 +42,7 @@ class LowerTypeScopePropagator extends TypeScopePropagator {
                 constraint.setLb((lowerBound - getSingleCount()));
         }
 
-        public static class Factory extends TypeScopePropagator.Factory {
+        static class Factory extends TypeScopePropagator.Factory {
                 private final PartialRelation type;
                 private final int lowerBound;
                 private final RelationalQuery allMay;
@@ -77,10 +80,18 @@ class LowerTypeScopePropagator extends TypeScopePropagator {
                                                         output.assign(sub(constant(lowerBound), candidateLowerBound)),
                                                         check(greater(output, constant(0)))
                                         )));
+                        var tooFewObjects = Query.of(type.name() + "#tooFew", builder -> builder
+                                        .clause(UpperCardinality.class, upperBound -> List.of(
+                                                        new CountUpperBoundLiteral(upperBound, type, List.of(Variable.of())),
+                                                        check(UpperCardinalityTerms.less(upperBound,
+                                                                        UpperCardinalityTerms.constant(UpperCardinality.of(lowerBound))))
+                                        )));
 
                         storeBuilder.getAdapter(ReasoningBuilder.class).objective(Objectives.value(requiredObjects));
-                        storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class).ifPresent(dseBuilder ->
-                                        dseBuilder.accept(Criteria.whenNoMatch(requiredObjects)));
+                        storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class).ifPresent(dseBuilder -> {
+                dseBuilder.accept(Criteria.whenNoMatch(requiredObjects));
+                                dseBuilder.exclude(Criteria.whenHasMatch(tooFewObjects));
+            });
                 }
         }
 }
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/TypeScopePropagator.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/TypeScopePropagator.java
index bb50656b..193c132c 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/TypeScopePropagator.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/TypeScopePropagator.java
@@ -59,7 +59,7 @@ abstract class TypeScopePropagator {
                 adapter.markAsChanged();
         }
 
-        public abstract static class Factory {
+        abstract static class Factory {
                 public abstract TypeScopePropagator createPropagator(BoundScopePropagator adapter);
 
                 protected abstract Collection<AnyQuery> getQueries();
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/UpperTypeScopePropagator.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/UpperTypeScopePropagator.java
index 4aba5aac..b2f8d39b 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/UpperTypeScopePropagator.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/UpperTypeScopePropagator.java
@@ -5,14 +5,24 @@
  */
 package tools.refinery.store.reasoning.scope;
 
+import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
+import tools.refinery.store.dse.transition.objectives.Criteria;
+import tools.refinery.store.dse.transition.objectives.Objectives;
+import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.literal.CountCandidateUpperBoundLiteral;
+import tools.refinery.store.reasoning.literal.CountLowerBoundLiteral;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
 import java.util.Collection;
 import java.util.List;
 
+import static tools.refinery.store.query.literal.Literals.check;
+import static tools.refinery.store.query.term.int_.IntTerms.*;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
 import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
@@ -30,12 +40,14 @@ class UpperTypeScopePropagator extends TypeScopePropagator {
                 constraint.setUb((upperBound - getSingleCount()));
         }
 
-        public static class Factory extends TypeScopePropagator.Factory {
+        static class Factory extends TypeScopePropagator.Factory {
+                private final PartialRelation type;
                 private final int upperBound;
                 private final RelationalQuery allMust;
                 private final RelationalQuery multiMust;
 
                 public Factory(PartialRelation type, int upperBound) {
+                        this.type = type;
                         this.upperBound = upperBound;
                         allMust = Query.of(type.name() + "#must", (builder, instance) -> builder.clause(
                                         must(type.call(instance))
@@ -55,5 +67,28 @@ class UpperTypeScopePropagator extends TypeScopePropagator {
                 protected Collection<AnyQuery> getQueries() {
                         return List.of(allMust, multiMust);
                 }
+
+                @Override
+                public void configure(ModelStoreBuilder storeBuilder) {
+                        super.configure(storeBuilder);
+
+                        var excessObjects = Query.of(type.name() + "#excess", Integer.class, (builder, output) -> builder
+                                        .clause(Integer.class, candidateUpperBound -> List.of(
+                                                        new CountCandidateUpperBoundLiteral(candidateUpperBound, type, List.of(Variable.of())),
+                                                        output.assign(sub(candidateUpperBound, constant(upperBound))),
+                                                        check(greater(output, constant(0)))
+                                        )));
+                        var tooManyObjects = Query.of(type.name() + "#tooMany", builder -> builder
+                                        .clause(Integer.class, lowerBound -> List.of(
+                                                        new CountLowerBoundLiteral(lowerBound, type, List.of(Variable.of())),
+                                                        check(greater(lowerBound, constant(upperBound)))
+                                        )));
+
+                        storeBuilder.getAdapter(ReasoningBuilder.class).objective(Objectives.value(excessObjects));
+                        storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class).ifPresent(dseBuilder -> {
+                dseBuilder.accept(Criteria.whenNoMatch(excessObjects));
+                                dseBuilder.exclude(Criteria.whenHasMatch(tooManyObjects));
+            });
+                }
         }
 }
diff --git a/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java b/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java
new file mode 100644
index 00000000..a2c56a6b
--- /dev/null
+++ b/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/PredicateScopeTest.java
@@ -0,0 +1,157 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.scope;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
+import tools.refinery.store.dse.strategy.BestFirstStoreManager;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
+import tools.refinery.store.reasoning.translator.metamodel.Metamodel;
+import tools.refinery.store.reasoning.translator.metamodel.MetamodelTranslator;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
+import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.statecoding.StateCoderAdapter;
+import tools.refinery.store.tuple.Tuple;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static tools.refinery.store.query.literal.Literals.not;
+
+class PredicateScopeTest {
+        private static final PartialRelation index = new PartialRelation("Index", 1);
+        private static final PartialRelation next = new PartialRelation("next", 2);
+        private static final PartialRelation nextInvalidMultiplicity = new PartialRelation("next::invalidMultiplicity", 1);
+        private static final PartialRelation prev = new PartialRelation("prev", 2);
+        private static final PartialRelation prevInvalidMultiplicity = new PartialRelation("prev::invalidMultiplicity", 1);
+        private static final PartialRelation loop = new PartialRelation("loop", 1);
+        private static final PartialRelation first = new PartialRelation("first", 1);
+        private static final PartialRelation last = new PartialRelation("last", 1);
+
+        @Tag("slow")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 3, 4, 5})
+        void generateTest(int randomSeed) {
+                var store = createStore();
+                var newIndex = Tuple.of(0);
+                var modelSeed = ModelSeed.builder(1)
+                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
+                                                .reducedValue(CardinalityIntervals.ONE)
+                                                .put(newIndex, CardinalityIntervals.SET))
+                                .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL,
+                                                builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(index, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(newIndex, TruthValue.TRUE))
+                                .seed(next, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(prev, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .build();
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                var initialVersion = model.commit();
+                var bestFistSearch = new BestFirstStoreManager(store, 1);
+                bestFistSearch.startExploration(initialVersion, randomSeed);
+                model.restore(bestFistSearch.getSolutionStore().getSolutions().get(0).version());
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                var firstInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, first);
+                assertSize(firstInterpretation, 1);
+                var lastInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, last);
+                assertSize(lastInterpretation, 1);
+        }
+
+        @Test
+        void invalidResultTest() {
+                var store = createStore();
+                var modelSeed = ModelSeed.builder(8)
+                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder.reducedValue(CardinalityIntervals.ONE))
+                                .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL,
+                                                builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(ContainmentHierarchyTranslator.CONTAINS_SYMBOL,
+                                                builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(index, builder -> builder.reducedValue(TruthValue.TRUE))
+                                .seed(next, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(Tuple.of(1, 2), TruthValue.TRUE)
+                                                .put(Tuple.of(2, 3), TruthValue.TRUE)
+                                                .put(Tuple.of(3, 4), TruthValue.TRUE)
+                                                .put(Tuple.of(4, 5), TruthValue.TRUE)
+                                                .put(Tuple.of(6, 1), TruthValue.TRUE))
+                                .seed(prev, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .build();
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                var firstInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, first);
+                assertSize(firstInterpretation, 3);
+                var lastInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.CANDIDATE, last);
+                assertSize(lastInterpretation, 3);
+                var designSpaceAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                assertThat(designSpaceAdapter.checkAccept(), is(false));
+        }
+
+        private ModelStore createStore() {
+                var metamodel = Metamodel.builder()
+                                .type(index)
+                                .reference(next, index, false,
+                                                ConstrainedMultiplicity.of(CardinalityIntervals.LONE, nextInvalidMultiplicity), index, prev)
+                                .reference(prev, index, false,
+                                                ConstrainedMultiplicity.of(CardinalityIntervals.LONE, prevInvalidMultiplicity), index, next)
+                                .build();
+                return ModelStore.builder()
+                                .with(QueryInterpreterAdapter.builder())
+                                .with(StateCoderAdapter.builder())
+                                .with(PropagationAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(ReasoningAdapter.builder())
+                                .with(new MultiObjectTranslator())
+                                .with(new MetamodelTranslator(metamodel))
+                                .with(PartialRelationTranslator.of(loop)
+                                                .query(Query.of("loop", (builder, p1) -> builder.clause(
+                                                                index.call(p1),
+                                                                next.callTransitive(p1, p1)
+                                                )))
+                                                .mayNever())
+                                .with(PartialRelationTranslator.of(first)
+                                                .query(Query.of("first", (builder, p1) -> builder.clause(
+                                                                index.call(p1),
+                                                                not(prev.call(p1, Variable.of()))
+                                                ))))
+                                .with(PartialRelationTranslator.of(last)
+                                                .query(Query.of("last", (builder, p1) -> builder.clause(
+                                                                index.call(p1),
+                                                                not(next.call(p1, Variable.of()))
+                                                ))))
+                                .with(new ScopePropagator()
+                                                .scope(index, CardinalityIntervals.exactly(8))
+                                                .scope(first, CardinalityIntervals.ONE)
+                                                .scope(last, CardinalityIntervals.ONE))
+                                .build();
+        }
+
+        private void assertSize(PartialInterpretation<TruthValue, Boolean> partialInterpretation, int expected) {
+                int size = 0;
+                var cursor = partialInterpretation.getAll();
+                while (cursor.move()) {
+                        assertThat(cursor.getValue(), is(TruthValue.TRUE));
+                        size++;
+                }
+                assertThat(size, is(expected));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
index 61037be3..c85bd8b7 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
@@ -52,9 +52,10 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
 
         private final Symbol<InferredContainment> containsStorage = Symbol.of("CONTAINS", 2, InferredContainment.class,
                         InferredContainment.UNKNOWN);
+        private final AnySymbolView mustAnyContainmentLinkView = new MustAnyContainmentLinkView(containsStorage);
         private final AnySymbolView forbiddenContainsView = new ForbiddenContainsView(containsStorage);
         private final RelationalQuery containsMayNewTargetHelper;
-        private final RelationalQuery containsMayExistingHelper;
+        private final RelationalQuery containsWithoutLink;
         private final RelationalQuery weakComponents;
         private final RelationalQuery strongComponents;
         private final Map<PartialRelation, ContainmentInfo> containmentInfoMap;
@@ -67,18 +68,15 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                 containsMayNewTargetHelper = Query.of(name + "#mayNewTargetHelper", (builder, child) -> builder
                                 .clause(Integer.class, existingContainers -> List.of(
                                                 may(CONTAINED_SYMBOL.call(child)),
-                                                new CountLowerBoundLiteral(existingContainers, CONTAINS_SYMBOL, List.of(Variable.of(), child)),
+                                                new CountLowerBoundLiteral(existingContainers, CONTAINS_SYMBOL,
+                                                                List.of(Variable.of(), child)),
                                                 check(less(existingContainers, constant(1)))
                                 )));
 
-                containsMayExistingHelper = Query.of(name + "#mayExistingHelper", (builder, parent, child) -> builder
-                                .clause(Integer.class, existingContainers -> List.of(
-                                                must(CONTAINS_SYMBOL.call(parent, child)),
-                                                not(forbiddenContainsView.call(parent, child))
-                                                // Violation of monotonicity:
-                                                // Containment edges violating upper multiplicity will not be marked as {@code ERROR}, but the
-                                                // {@code invalidNumberOfContainers} error pattern will already mark the node as invalid.
-                                )));
+                containsWithoutLink = Query.of(name + "#withoutLink", (builder, parent, child) -> builder.clause(
+                                must(CONTAINS_SYMBOL.call(parent, child)),
+                                not(mustAnyContainmentLinkView.call(parent, child))
+                ));
 
                 var mustExistBothContains = Query.of(name + "#mustExistBoth", (builder, parent, child) -> builder.clause(
                                 must(CONTAINS_SYMBOL.call(parent, child)),
@@ -139,13 +137,21 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                 var mayNewHelper = Query.of(name + "#mayNewHelper", (builder, parent, child) -> builder.clause(
                                 mayNewSourceHelper.call(parent),
                                 mayNewTargetHelper.call(child),
-                                not(must(CONTAINS_SYMBOL.call(parent, child))),
+                                not(mustAnyContainmentLinkView.call(parent, child)),
                                 not(forbiddenLinkView.call(parent, child))
                 ));
 
+                var existingContainsLink = Query.of(name + "#existingContaints", (builder, parent, child) -> builder
+                                .clause(
+                                                must(linkType.call(parent, child))
+                                )
+                                .clause(
+                                                containsWithoutLink.call(parent, child)
+                                ));
+
                 var mayExistingHelper = Query.of(name + "#mayExistingHelper", (builder, parent, child) -> builder.clause(
-                                must(linkType.call(parent, child)),
-                                containsMayExistingHelper.call(parent, child),
+                                existingContainsLink.call(parent, child),
+                                not(forbiddenContainsView.call(parent, child)),
                                 may(sourceType.call(parent)),
                                 may(targetType.call(child)),
                                 not(forbiddenLinkView.call(parent, child))
@@ -224,7 +230,9 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 }))
                                 .must(Query.of(mustName, (builder, parent, child) -> builder.clause(
                                                 new MustContainsView(containsStorage).call(parent, child)
-                                ))));
+                                )))
+                                .refiner(ContainsRefiner.of(containsStorage))
+                                .initializer(new RefinementBasedInitializer<>(CONTAINS_SYMBOL)));
         }
 
         private void translateInvalidContainer(ModelStoreBuilder storeBuilder) {
@@ -245,7 +253,7 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 )
                                 .clause(container -> List.of(
                                                 MultiObjectTranslator.MULTI_VIEW.call(multi),
-                                                must(CONTAINS_SYMBOL.call(container, multi)),
+                                                mustAnyContainmentLinkView.call(container, multi),
                                                 not(MultiObjectTranslator.MULTI_VIEW.call(container))
                                 ))
                                 .action(
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
index 497ed98f..e44fcffd 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
@@ -24,8 +24,8 @@ class ContainmentLinkRefiner extends AbstractPartialInterpretationRefiner<TruthV
         private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
         private final PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
 
-        public ContainmentLinkRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
-                                                                  Factory factory) {
+        private ContainmentLinkRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                                   Factory factory) {
                 super(adapter, partialSymbol);
                 this.factory = factory;
                 interpretation = adapter.getModel().getInterpretation(factory.symbol);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
new file mode 100644
index 00000000..a7196a1c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+class ContainsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, Boolean> {
+        private static final Map<TruthValue, InferredContainment> EMPTY_VALUES;
+
+        static {
+                var values = TruthValue.values();
+                EMPTY_VALUES = new LinkedHashMap<>(values.length);
+                for (var value : values) {
+                        EMPTY_VALUES.put(value, new InferredContainment(value, Set.of(), Set.of()));
+                }
+        }
+
+        private final Interpretation<InferredContainment> interpretation;
+        private final PartialInterpretationRefiner<TruthValue, Boolean> containedRefiner;
+
+        private ContainsRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                        Symbol<InferredContainment> containsStorage) {
+                super(adapter, partialSymbol);
+                interpretation = adapter.getModel().getInterpretation(containsStorage);
+                containedRefiner = adapter.getRefiner(ContainmentHierarchyTranslator.CONTAINED_SYMBOL);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                var oldValue = interpretation.get(key);
+                var newValue = mergeLink(oldValue, value);
+                if (oldValue != newValue) {
+                        interpretation.put(key, newValue);
+                }
+                if (value.must()) {
+                        return containedRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                }
+                return true;
+        }
+
+        public InferredContainment mergeLink(InferredContainment oldValue, TruthValue toMerge) {
+                var newContains = oldValue.contains().merge(toMerge);
+                if (newContains.equals(oldValue.contains())) {
+                        return oldValue;
+                }
+                var mustLinks = oldValue.mustLinks();
+                var forbiddenLinks = oldValue.forbiddenLinks();
+                if (mustLinks.isEmpty() && forbiddenLinks.isEmpty()) {
+                        return EMPTY_VALUES.get(newContains);
+                }
+                return new InferredContainment(newContains, mustLinks, forbiddenLinks);
+        }
+
+        public static PartialInterpretationRefiner.Factory<TruthValue, Boolean> of(Symbol<InferredContainment> symbol) {
+                return (adapter, partialSymbol) -> new ContainsRefiner(adapter, partialSymbol, symbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
index 8df23d9a..8a757ed2 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
@@ -24,7 +24,7 @@ final class InferredContainment {
                 this.contains = adjustContains(contains, mustLinks, forbiddenLinks);
                 this.mustLinks = mustLinks;
                 this.forbiddenLinks = forbiddenLinks;
-                hashCode = Objects.hash(contains, mustLinks, forbiddenLinks);
+                hashCode = Objects.hash(this.contains, mustLinks, forbiddenLinks);
         }
 
         private static TruthValue adjustContains(TruthValue contains, Set<PartialRelation> mustLinks,
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustAnyContainmentLinkView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustAnyContainmentLinkView.java
new file mode 100644
index 00000000..1cc537c6
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustAnyContainmentLinkView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.query.view.TuplePreservingView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class MustAnyContainmentLinkView extends TuplePreservingView<InferredContainment> {
+        public MustAnyContainmentLinkView(Symbol<InferredContainment> symbol) {
+                super(symbol, "contains#mustAnyLink");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredContainment value) {
+                return !value.mustLinks().isEmpty();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
index 0700f9f7..2e804b44 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
@@ -15,15 +15,17 @@ import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
 
 class DirectedCrossReferenceRefiner extends ConcreteSymbolRefiner<TruthValue, Boolean> {
+        private final PartialRelation targetType;
         private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
-        private final PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
+        private PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
 
         public DirectedCrossReferenceRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
                                                                                  Symbol<TruthValue> concreteSymbol, PartialRelation sourceType,
                                                                                  PartialRelation targetType) {
                 super(adapter, partialSymbol, concreteSymbol);
+                this.targetType = targetType;
+                // Source is always a class, so we can rely on the fact that it is always constructed before this refiner.
                 sourceRefiner = adapter.getRefiner(sourceType);
-                targetRefiner = adapter.getRefiner(targetType);
         }
 
         @Override
@@ -32,6 +34,10 @@ class DirectedCrossReferenceRefiner extends ConcreteSymbolRefiner<TruthValue, Bo
                         return false;
                 }
                 if (value.must()) {
+                        if (targetRefiner == null) {
+                                // Access the target refinery lazily, since it may be constructed after this refiner.
+                                targetRefiner = getAdapter().getRefiner(targetType);
+                        }
                         return sourceRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
                                         targetRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
                 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
index ad0288ed..74022fc6 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
@@ -153,15 +153,11 @@ public class MetamodelBuilder {
                         return;
                 }
                 var sourceType = info.sourceType();
-                var targetType = info.targetType();
                 if (typeHierarchyBuilder.isInvalidType(sourceType)) {
                         throw new TranslationException(linkType, "Source type %s of %s is not in type hierarchy"
                                         .formatted(sourceType, linkType));
                 }
-                if (typeHierarchyBuilder.isInvalidType(targetType)) {
-                        throw new TranslationException(linkType, "Target type %s of %s is not in type hierarchy"
-                                        .formatted(targetType, linkType));
-                }
+                var targetType = info.targetType();
                 var opposite = info.opposite();
                 Multiplicity targetMultiplicity = UnconstrainedMultiplicity.INSTANCE;
                 if (opposite != null) {
@@ -185,18 +181,30 @@ public class MetamodelBuilder {
                         oppositeReferences.put(opposite, linkType);
                 }
                 if (info.containment()) {
-                        if (!UnconstrainedMultiplicity.INSTANCE.equals(targetMultiplicity)) {
-                                throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
-                                                .formatted(opposite, targetMultiplicity, linkType));
-                        }
-                        containedTypes.add(targetType);
-                        containmentHierarchy.put(linkType, new ContainmentInfo(sourceType, info.multiplicity(), targetType));
+                        processContainmentInfo(linkType, info, targetMultiplicity);
                         return;
                 }
                 directedCrossReferences.put(linkType, new DirectedCrossReferenceInfo(sourceType, info.multiplicity(),
                                 targetType, targetMultiplicity));
         }
 
+        private void processContainmentInfo(PartialRelation linkType, ReferenceInfo info,
+                                                                                Multiplicity targetMultiplicity) {
+                var sourceType = info.sourceType();
+                var targetType = info.targetType();
+                var opposite = info.opposite();
+                if (typeHierarchyBuilder.isInvalidType(targetType)) {
+                        throw new TranslationException(linkType, "Target type %s of %s is not in type hierarchy"
+                                        .formatted(targetType, linkType));
+                }
+                if (!UnconstrainedMultiplicity.INSTANCE.equals(targetMultiplicity)) {
+                        throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
+                                        .formatted(opposite, targetMultiplicity, linkType));
+                }
+                containedTypes.add(targetType);
+                containmentHierarchy.put(linkType, new ContainmentInfo(sourceType, info.multiplicity(), targetType));
+        }
+
         private static void validateOpposite(PartialRelation linkType, ReferenceInfo info, PartialRelation opposite,
                                                                                  ReferenceInfo oppositeInfo) {
                 var sourceType = info.sourceType();