feat: container type propagation

18 files changed, 177 insertions, 14 deletions

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 fbcbe6ce..1a9100c9 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
@@ -122,6 +122,8 @@ public class ModelInitializer {
                         putRelationInfo(builtinSymbols.equals(), new RelationInfo(ReasoningAdapter.EQUALS_SYMBOL,
                                         (TruthValue) null,
                                         null));
+                        putRelationInfo(builtinSymbols.container(),
+                                        new RelationInfo(ContainmentHierarchyTranslator.CONTAINER_SYMBOL, null, TruthValue.UNKNOWN));
                         putRelationInfo(builtinSymbols.contained(),
                                         new RelationInfo(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, null, TruthValue.UNKNOWN));
                         putRelationInfo(builtinSymbols.contains(), new RelationInfo(ContainmentHierarchyTranslator.CONTAINS_SYMBOL,
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java b/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java
index 72f23e85..3b2ae707 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/BuiltinSymbols.java
@@ -12,6 +12,7 @@ public final class BuiltinSymbols {
     private final ClassDeclaration node;
     private final PredicateDefinition equals;
     private final PredicateDefinition exists;
+        private final ClassDeclaration container;
     private final ClassDeclaration contained;
     private final PredicateDefinition contains;
     private final PredicateDefinition invalidContainer;
@@ -21,6 +22,7 @@ public final class BuiltinSymbols {
                 node = getDeclaration(ClassDeclaration.class, "node");
                 equals = getDeclaration(PredicateDefinition.class, "equals");
                 exists = getDeclaration(PredicateDefinition.class, "exists");
+                container = getDeclaration(ClassDeclaration.class, "container");
                 contained = getDeclaration(ClassDeclaration.class, "contained");
                 contains = getDeclaration(PredicateDefinition.class, "contains");
                 invalidContainer = getDeclaration(PredicateDefinition.class, "invalidContainer");
@@ -42,6 +44,10 @@ public final class BuiltinSymbols {
         return exists;
     }
 
+        public ClassDeclaration container() {
+                return container;
+        }
+
     public ClassDeclaration contained() {
         return contained;
     }
diff --git a/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery b/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
index 09c7d92b..6ae6beb1 100644
--- a/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
+++ b/subprojects/language/src/main/resources/tools/refinery/language/library/builtin.refinery
@@ -8,6 +8,8 @@ pred exists(node).
 
 pred equals(left, right).
 
+abstract class container extends node.
+
 abstract class contained extends node.
 
 pred contains(container, contained contained).
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
index f4d5fb60..c39e603b 100644
--- 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
@@ -56,6 +56,8 @@ class PredicateScopeTest {
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(newIndex, CardinalityIntervals.SET))
+                                .seed(ContainmentHierarchyTranslator.CONTAINER_SYMBOL,
+                                                builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL,
                                                 builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(index, builder -> builder
@@ -81,6 +83,8 @@ class PredicateScopeTest {
                 var store = createStore();
                 var modelSeed = ModelSeed.builder(8)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder.reducedValue(CardinalityIntervals.ONE))
+                                .seed(ContainmentHierarchyTranslator.CONTAINER_SYMBOL,
+                                                builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL,
                                                 builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINS_SYMBOL,
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainerTypeInferenceTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainerTypeInferenceTranslator.java
new file mode 100644
index 00000000..76e4b5d1
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainerTypeInferenceTranslator.java
@@ -0,0 +1,114 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.logic.literal.Literal;
+import tools.refinery.logic.term.Variable;
+import tools.refinery.store.dse.propagation.PropagationBuilder;
+import tools.refinery.store.dse.transition.Rule;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.typehierarchy.TypeHierarchy;
+
+import java.util.*;
+
+import static tools.refinery.logic.literal.Literals.not;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.remove;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
+import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.*;
+
+public class ContainerTypeInferenceTranslator implements ModelStoreConfiguration {
+        private final TypeHierarchy typeHierarchy;
+        private final Map<PartialRelation, Set<PartialRelation>> possibleContents = new LinkedHashMap<>();
+        private final Map<PartialRelation, Set<PartialRelation>> possibleContainers = new LinkedHashMap<>();
+
+        public ContainerTypeInferenceTranslator(TypeHierarchy typeHierarchy,
+                                                                                        Map<PartialRelation, ContainmentInfo> containmentInfoMap) {
+                this.typeHierarchy = typeHierarchy;
+                for (var containedType : typeHierarchy.getAnalysisResult(CONTAINER_SYMBOL).getConcreteSubtypesAndSelf()) {
+                        possibleContents.put(containedType, new LinkedHashSet<>());
+                }
+                for (var containedType : typeHierarchy.getAnalysisResult(CONTAINED_SYMBOL).getConcreteSubtypesAndSelf()) {
+                        possibleContainers.put(containedType, new LinkedHashSet<>());
+                }
+                for (var entry : containmentInfoMap.entrySet()) {
+                        var containmentLink = entry.getKey();
+                        var containmentInfo = entry.getValue();
+                        var sourceType = containmentInfo.sourceType();
+                        for (var subtype : typeHierarchy.getAnalysisResult(sourceType).getConcreteSubtypesAndSelf()) {
+                                possibleContents.get(subtype).add(containmentLink);
+                        }
+                        var targetType = containmentInfo.targetType();
+                        for (var subtype : typeHierarchy.getAnalysisResult(targetType).getConcreteSubtypesAndSelf()) {
+                                possibleContainers.get(subtype).add(containmentLink);
+                        }
+                }
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.tryGetAdapter(PropagationBuilder.class).ifPresent(this::configurePropagationBuilder);
+        }
+
+        private void configurePropagationBuilder(PropagationBuilder propagationBuilder) {
+                configureContainerPropagator(propagationBuilder);
+                configureContainedPropagator(propagationBuilder);
+        }
+
+        private void configureContainerPropagator(PropagationBuilder propagationBuilder) {
+                for (var entry : possibleContents.entrySet()) {
+                        var sourceType = entry.getKey();
+                        var contents = entry.getValue();
+                        propagationBuilder.rule(Rule.of(sourceType.name() + "#notContainer", (builder, source) -> builder
+                                        .clause(target -> {
+                                                var literals = new ArrayList<Literal>();
+                                                literals.add(may(sourceType.call(source)));
+                                                literals.add(not(must(sourceType.call(source))));
+                                                literals.add(must(CONTAINS_SYMBOL.call(source, target)));
+                                                var typeInfo = typeHierarchy.getAnalysisResult(sourceType);
+                                                for (var subtype : typeInfo.getDirectSubtypes()) {
+                                                        literals.add(not(may(subtype.call(source))));
+                                                }
+                                                for (var content : contents) {
+                                                        literals.add(not(may(content.call(source, target))));
+                                                }
+                                                return literals;
+                                        })
+                                        .action(
+                                                        remove(sourceType, source)
+                                        )
+                        ));
+                }
+        }
+
+        private void configureContainedPropagator(PropagationBuilder propagationBuilder) {
+                for (var entry : possibleContainers.entrySet()) {
+                        var targetType = entry.getKey();
+                        var containers = entry.getValue();
+                        propagationBuilder.rule(Rule.of(targetType.name() + "#notContent", (builder, target) -> builder
+                                        .clause(() -> {
+                                                var literals = new ArrayList<Literal>();
+                                                literals.add(may(targetType.call(target)));
+                                                literals.add(not(must(targetType.call(target))));
+                                                literals.add(must(CONTAINED_SYMBOL.call(target)));
+                                                var typeInfo = typeHierarchy.getAnalysisResult(targetType);
+                                                for (var subtype : typeInfo.getDirectSubtypes()) {
+                                                        literals.add(not(may(subtype.call(target))));
+                                                }
+                                                for (var container : containers) {
+                                                        literals.add(not(may(container.call(Variable.of(), target))));
+                                                }
+                                                return literals;
+                                        })
+                                        .action(
+                                                        remove(targetType, target)
+                                        )
+                        ));
+                }
+        }
+}
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 c862bc33..b15a2576 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
@@ -50,6 +50,7 @@ import static tools.refinery.store.reasoning.actions.PartialActionLiterals.focus
 import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
 
 public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
+        public static final PartialRelation CONTAINER_SYMBOL = new PartialRelation("container", 1);
         public static final PartialRelation CONTAINED_SYMBOL = new PartialRelation("contained", 1);
         public static final PartialRelation INVALID_CONTAINER = new PartialRelation("invalidContainer",
                         1);
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
index 00820040..024774bc 100644
--- 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
@@ -30,12 +30,14 @@ class ContainsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, B
         }
 
         private final Interpretation<InferredContainment> interpretation;
+        private final PartialInterpretationRefiner<TruthValue, Boolean> containerRefiner;
         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);
+                containerRefiner = adapter.getRefiner(ContainmentHierarchyTranslator.CONTAINER_SYMBOL);
                 containedRefiner = adapter.getRefiner(ContainmentHierarchyTranslator.CONTAINED_SYMBOL);
         }
 
@@ -47,7 +49,8 @@ class ContainsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, B
                         interpretation.put(key, newValue);
                 }
                 if (value.must()) {
-                        return containedRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                        return containerRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
+                                        containedRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
                 }
                 return true;
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java
index 41d185d7..b322513d 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java
@@ -30,7 +30,6 @@ import static tools.refinery.logic.literal.Literals.check;
 import static tools.refinery.logic.literal.Literals.not;
 import static tools.refinery.logic.term.int_.IntTerms.constant;
 import static tools.refinery.logic.term.int_.IntTerms.less;
-import static tools.refinery.store.reasoning.ReasoningAdapter.EQUALS_SYMBOL;
 import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
 import static tools.refinery.store.reasoning.actions.PartialActionLiterals.remove;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
index a21da3d4..1cd564bd 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
@@ -20,6 +20,17 @@ public class ContainedTypeHierarchyBuilder extends TypeHierarchyBuilder {
                 return !typeInfoMap.containsKey(type);
         }
 
+        void setContainerTypes(Collection<PartialRelation> containerTypes) {
+                for (var containerType : containerTypes) {
+                        var currentInfo = typeInfoMap.get(containerType);
+                        if (currentInfo == null) {
+                                throw new TranslationException(containerType, "Invalid container type: " + containerType);
+                        }
+                        var newInfo = currentInfo.addSupertype(ContainmentHierarchyTranslator.CONTAINER_SYMBOL);
+                        typeInfoMap.put(containerType, newInfo);
+                }
+        }
+
         void setContainedTypes(Collection<PartialRelation> containedTypes) {
                 for (var containedType : containedTypes) {
                         var currentInfo = typeInfoMap.get(containedType);
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 94bf1c5d..740fe231 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
@@ -21,6 +21,7 @@ import java.util.function.Consumer;
 public class MetamodelBuilder {
         private final ContainedTypeHierarchyBuilder typeHierarchyBuilder = new ContainedTypeHierarchyBuilder();
         private final Map<PartialRelation, ReferenceInfo> referenceInfoMap = new LinkedHashMap<>();
+        private final Set<PartialRelation> containerTypes = new HashSet<>();
         private final Set<PartialRelation> containedTypes = new HashSet<>();
         private final Map<PartialRelation, ContainmentInfo> containmentHierarchy = new LinkedHashMap<>();
         private final Map<PartialRelation, DirectedCrossReferenceInfo> directedCrossReferences = new LinkedHashMap<>();
@@ -28,6 +29,7 @@ public class MetamodelBuilder {
         private final Map<PartialRelation, PartialRelation> oppositeReferences = new LinkedHashMap<>();
 
         MetamodelBuilder() {
+                typeHierarchyBuilder.type(ContainmentHierarchyTranslator.CONTAINER_SYMBOL, true);
                 typeHierarchyBuilder.type(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, true);
         }
 
@@ -105,6 +107,7 @@ public class MetamodelBuilder {
                         var info = entry.getValue();
                         processReferenceInfo(linkType, info);
                 }
+                typeHierarchyBuilder.setContainerTypes(containerTypes);
                 typeHierarchyBuilder.setContainedTypes(containedTypes);
                 var typeHierarchy = typeHierarchyBuilder.build();
                 return new Metamodel(typeHierarchy, Collections.unmodifiableMap(containmentHierarchy),
@@ -169,6 +172,7 @@ public class MetamodelBuilder {
                         throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
                                         .formatted(opposite, targetMultiplicity, linkType));
                 }
+                containerTypes.add(sourceType);
                 containedTypes.add(targetType);
                 containmentHierarchy.put(linkType, new ContainmentInfo(sourceType, info.multiplicity(), targetType));
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java
index 5afa58f2..36b2d9a1 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java
@@ -7,6 +7,7 @@ package tools.refinery.store.reasoning.translator.metamodel;
 
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.reasoning.translator.containment.ContainerTypeInferenceTranslator;
 import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
 import tools.refinery.store.reasoning.translator.crossreference.DirectedCrossReferenceTranslator;
 import tools.refinery.store.reasoning.translator.crossreference.UndirectedCrossReferenceTranslator;
@@ -24,6 +25,8 @@ public class MetamodelTranslator implements ModelStoreConfiguration {
         public void apply(ModelStoreBuilder storeBuilder) {
                 storeBuilder.with(new TypeHierarchyTranslator(metamodel.typeHierarchy()));
                 storeBuilder.with(new ContainmentHierarchyTranslator(metamodel.containmentHierarchy()));
+                storeBuilder.with(new ContainerTypeInferenceTranslator(metamodel.typeHierarchy(),
+                                metamodel.containmentHierarchy()));
                 for (var entry : metamodel.directedCrossReferences().entrySet()) {
                         storeBuilder.with(new DirectedCrossReferenceTranslator(entry.getKey(), entry.getValue()));
                 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java
index 7a917dcf..f2de384f 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java
@@ -51,7 +51,7 @@ final class ExtendedTypeInfo implements Comparable<ExtendedTypeInfo> {
         }
 
         public Set<PartialRelation> getAllSupertypesAndSelf() {
-                var allSubtypesAndSelf = new HashSet<PartialRelation>(allSupertypes.size() + 1);
+                var allSubtypesAndSelf = HashSet.<PartialRelation>newHashSet(allSupertypes.size() + 1);
                 addMust(allSubtypesAndSelf);
                 return allSubtypesAndSelf;
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
index 324e2b9e..d20b4f4a 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
@@ -13,12 +13,14 @@ import java.util.*;
 public final class TypeAnalysisResult {
         private final ExtendedTypeInfo extendedTypeInfo;
         private final List<PartialRelation> directSubtypes;
+        private final Set<PartialRelation> concreteSubtypesAndSelf;
         private final List<ExtendedTypeInfo> allExternalTypeInfoList;
         private final InferredType inferredType;
 
-        public TypeAnalysisResult(ExtendedTypeInfo extendedTypeInfo, List<ExtendedTypeInfo> allExternalTypeInfoList) {
+        TypeAnalysisResult(ExtendedTypeInfo extendedTypeInfo, List<ExtendedTypeInfo> allExternalTypeInfoList) {
                 this.extendedTypeInfo = extendedTypeInfo;
                 directSubtypes = List.copyOf(extendedTypeInfo.getDirectSubtypes());
+                concreteSubtypesAndSelf = Collections.unmodifiableSet(extendedTypeInfo.getConcreteSubtypesAndSelf());
                 this.allExternalTypeInfoList = allExternalTypeInfoList;
                 inferredType = propagateMust(extendedTypeInfo.getAllSupertypesAndSelf(),
                                 extendedTypeInfo.getConcreteSubtypesAndSelf());
@@ -32,6 +34,10 @@ public final class TypeAnalysisResult {
                 return directSubtypes;
         }
 
+        public Set<PartialRelation> getConcreteSubtypesAndSelf() {
+                return concreteSubtypesAndSelf;
+        }
+
         public boolean isAbstractType() {
                 return extendedTypeInfo.isAbstractType();
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
index 3f918c97..ec74ed14 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
@@ -20,7 +20,7 @@ public class TypeHierarchy {
         TypeHierarchy(Map<PartialRelation, TypeInfo> typeInfoMap) {
                 int size = typeInfoMap.size();
                 allTypes = Collections.unmodifiableSet(new LinkedHashSet<>(typeInfoMap.keySet()));
-                extendedTypeInfoMap = new LinkedHashMap<>(size);
+                extendedTypeInfoMap = LinkedHashMap.newLinkedHashMap(size);
                 var concreteTypes = new LinkedHashSet<PartialRelation>();
                 int index = 0;
                 for (var entry : typeInfoMap.entrySet()) {
@@ -118,7 +118,7 @@ public class TypeHierarchy {
                 for (var extendedTypeInfo : extendedTypeInfoMap.values()) {
                         var allSubtypes = extendedTypeInfo.getAllSubtypes();
                         var directSubtypes = new LinkedHashSet<>(allSubtypes);
-                        var indirectSubtypes = new LinkedHashSet<PartialRelation>(allSubtypes.size());
+                        var indirectSubtypes = LinkedHashSet.<PartialRelation>newLinkedHashSet(allSubtypes.size());
                         for (var subtype : allSubtypes) {
                                 indirectSubtypes.addAll(extendedTypeInfoMap.get(subtype).getAllSubtypes());
                         }
@@ -203,7 +203,7 @@ public class TypeHierarchy {
 
         private Map<PartialRelation, TypeAnalysisResult> computeAnalysisResults() {
                 var allExtendedTypeInfoList = sortTypes();
-                var preservedResults = new LinkedHashMap<PartialRelation, TypeAnalysisResult>(
+                var preservedResults = LinkedHashMap.<PartialRelation, TypeAnalysisResult>newLinkedHashMap(
                                 allExtendedTypeInfoList.size());
                 for (var extendedTypeInfo : allExtendedTypeInfoList) {
                         var type = extendedTypeInfo.getType();
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
index 700bbe88..168d78df 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
@@ -22,6 +22,7 @@ import tools.refinery.store.representation.Symbol;
 import java.util.ArrayList;
 
 import static tools.refinery.logic.literal.Literals.not;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.candidateMust;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
 
@@ -92,7 +93,7 @@ public class TypeHierarchyTranslator implements ModelStoreConfiguration {
                                         )
                                         .action(() -> {
                                                 var actionLiterals = new ArrayList<ActionLiteral>();
-                                                actionLiterals.add(PartialActionLiterals.add(type, instance));
+                                                actionLiterals.add(add(type, instance));
                                                 for (var subtype : result.getDirectSubtypes()) {
                                                         actionLiterals.add(PartialActionLiterals.remove(subtype, instance));
                                                 }
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslatorTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslatorTest.java
index e889b80d..4d46ea63 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslatorTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslatorTest.java
@@ -26,8 +26,7 @@ import java.util.Map;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
-import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.CONTAINED_SYMBOL;
-import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.CONTAINS_SYMBOL;
+import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.*;
 import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.COUNT_SYMBOL;
 
 class ContainmentHierarchyTranslatorTest {
@@ -41,8 +40,9 @@ class ContainmentHierarchyTranslatorTest {
         void beforeEach() {
 
                 var typeHierarchy = TypeHierarchy.builder()
+                                .type(CONTAINER_SYMBOL, true)
                                 .type(CONTAINED_SYMBOL, true)
-                                .type(c1)
+                                .type(c1, CONTAINER_SYMBOL)
                                 .type(c2, c1, CONTAINED_SYMBOL)
                                 .build();
 
@@ -64,6 +64,7 @@ class ContainmentHierarchyTranslatorTest {
         void treeTest() {
                 var modelSeed = ModelSeed.builder(3)
                                 .seed(COUNT_SYMBOL, builder -> builder.reducedValue(CardinalityIntervals.ONE))
+                                .seed(CONTAINER_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(CONTAINED_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(CONTAINS_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(c1, builder -> builder
@@ -97,6 +98,7 @@ class ContainmentHierarchyTranslatorTest {
         void loopTest() {
                 var modelSeed = ModelSeed.builder(3)
                                 .seed(COUNT_SYMBOL, builder -> builder.reducedValue(CardinalityIntervals.ONE))
+                                .seed(CONTAINER_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(CONTAINED_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(CONTAINS_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(c1, builder -> builder.reducedValue(TruthValue.UNKNOWN))
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/DefaultContainmentTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/DefaultContainmentTest.java
index e80f9744..2f814b58 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/DefaultContainmentTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/containment/DefaultContainmentTest.java
@@ -27,8 +27,7 @@ import java.util.LinkedHashMap;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
-import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.CONTAINED_SYMBOL;
-import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.CONTAINS_SYMBOL;
+import static tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator.*;
 import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.COUNT_SYMBOL;
 
 class DefaultContainmentTest {
@@ -42,8 +41,9 @@ class DefaultContainmentTest {
         @ValueSource(booleans = {false, true})
         void defaultContainmentTest(boolean reverse) {
                 var typeHierarchy = TypeHierarchy.builder()
+                                .type(CONTAINER_SYMBOL, true)
                                 .type(CONTAINED_SYMBOL, true)
-                                .type(c1)
+                                .type(c1, CONTAINER_SYMBOL)
                                 .type(c2, CONTAINED_SYMBOL)
                                 .type(c3, CONTAINED_SYMBOL)
                                 .build();
@@ -60,6 +60,7 @@ class DefaultContainmentTest {
 
                 var modelSeed = ModelSeed.builder(3)
                                 .seed(COUNT_SYMBOL, builder -> builder.reducedValue(CardinalityIntervals.ONE))
+                                .seed(CONTAINER_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(CONTAINED_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(CONTAINS_SYMBOL, builder -> builder.reducedValue(TruthValue.UNKNOWN))
                                 .seed(c1, builder -> builder
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
index f8e9e1b5..f619d7dd 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
@@ -68,6 +68,8 @@ class MetamodelTest {
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(1), CardinalityIntervals.SET)
                                                 .put(Tuple.of(4), CardinalityIntervals.SET))
+                                .seed(ContainmentHierarchyTranslator.CONTAINER_SYMBOL, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, builder -> builder
                                                 .reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINS_SYMBOL, builder -> builder
@@ -126,6 +128,8 @@ class MetamodelTest {
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(0), CardinalityIntervals.SET)
                                                 .put(Tuple.of(1), CardinalityIntervals.SET))
+                                .seed(ContainmentHierarchyTranslator.CONTAINER_SYMBOL, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, builder -> builder
                                                 .reducedValue(TruthValue.UNKNOWN))
                                 .seed(ContainmentHierarchyTranslator.CONTAINS_SYMBOL, builder -> builder