Updated partial model representation handling

8 files changed, 192 insertions, 124 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend
index 3a85536b..e4ad4295 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend
@@ -10,9 +10,9 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.Partial2logicannotationsFactory

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink

 import java.util.ArrayList

 import java.util.HashMap

@@ -46,7 +46,7 @@ class PartialInterpretation2Logic {
                         addExistingElementToProblem(p,i,trace)

                         

                         // Types

-                        for(partialTypeDeclaration : i.partialtypeinterpratation) {

+                        for(partialTypeDeclaration : i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation)) {

                                 splitTypeIntoTwo(p,partialTypeDeclaration,trace)

                         }

                         connectSplittings(p,trace)

@@ -69,7 +69,7 @@ class PartialInterpretation2Logic {
                 p.elements += i.newElements

         }

         

-        private def splitTypeIntoTwo(LogicProblem p, PartialTypeInterpratation partialTypeDeclaration,PartialInterpretation2Logic_Trace trace) {

+        private def splitTypeIntoTwo(LogicProblem p, PartialComplexTypeInterpretation partialTypeDeclaration,PartialInterpretation2Logic_Trace trace) {

                 if(!partialTypeDeclaration.elements.empty) {

                         val declaration = partialTypeDeclaration.interpretationOf

                         

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
index ad9d882b..cdc79743 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
@@ -4,130 +4,152 @@ import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.logic.model.patterns.SupertypeStar

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.PartialModelRelation2Assertion

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialConstantInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialFunctionInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory

+import java.math.BigDecimal

 import java.util.HashMap

 import java.util.Map

+import java.util.SortedSet

+import org.eclipse.emf.ecore.util.EcoreUtil

 import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine

 import org.eclipse.viatra.query.runtime.emf.EMFScope

 import org.eclipse.xtend.lib.annotations.Data

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.PartialModelRelation2Assertion

-import org.eclipse.emf.ecore.util.EcoreUtil

 

 @Data class Problem2PartialInterpretationTrace {

-        Map<TypeDeclaration, PartialTypeInterpratation> type2Interpretation = new HashMap

+        Map<TypeDeclaration, PartialComplexTypeInterpretation> type2Interpretation = new HashMap

         Map<RelationDeclaration, PartialRelationInterpretation> relation2Interpretation = new HashMap

 }

 

+/**

+ * Initializer class for an empty partial interpretation.

+ */

 class PartialInterpretationInitialiser {

         val extension PartialinterpretationFactory factory = PartialinterpretationFactory.eINSTANCE

         val extension LogiclanguageFactory factory2 = LogiclanguageFactory.eINSTANCE

         

         /**

-         * Initialises an empty partial interpretation from a logic problem

+         * Initialises an empty partial interpretation from a logic problem and a scope.

          */

         def TracedOutput<PartialInterpretation,Problem2PartialInterpretationTrace> initialisePartialInterpretation(

                 LogicProblem problem,

                 TypeScopes typeScopes) 

         {

-                val engine = ViatraQueryEngine.on(new EMFScope(problem))

+                

                 val trace = new Problem2PartialInterpretationTrace

                 

                 val res = createPartialInterpretation => [

                         it.problem = problem

                         

-                        // Elements

-                        it.minNewElements = typeScopes.maxNewElements

-                        it.maxNewElements = typeScopes.minNewElements

-                        // elements from problem are included

-                        if(maxNewElements>0) {

-                                it.openWorldElementPrototypes += createDefinedElement => [it.name = "Symbolic New Element"]

-                        }

-                        

-                        // Booleans

-                        it.booleanelements += createBooleanElement => [it.name = "true" it.value = true it.valueSet = true]

-                        it.booleanelements += createBooleanElement => [it.name = "false" it.value = false it.valueSet = true]

+                        // Initialise primitive elements

+                        initBooleans(it)

+                        initIntegers(it, typeScopes.knownIntegers, typeScopes.minNewIntegers, typeScopes.maxNewIntegers)

+                        initReals(it, typeScopes.knownReals, typeScopes.minNewReals, typeScopes.maxNewReals)

+                        initStrings(it,typeScopes.knownStrings, typeScopes.minNewStrings, typeScopes.maxNewStrings)

+                        // Initialise complex elements

+                        initElements(it,

+                                typeScopes.minNewElementsByType,

+                                typeScopes.maxNewElementsByType,

+                                typeScopes.minNewElements,

+                                typeScopes.maxNewElements,

+                                trace

+                        )

                         

-                        // Integers

-                        it.maxNewIntegers = typeScopes.maxNewIntegers

-                        val knownIntegers = (typeScopes.knownIntegers + problem.eAllContents.toIterable.filter(IntLiteral).map[value]).toSet

-                        for(integersInProblem : knownIntegers) {

-                                it.integerelements += createIntegerElement => [it.name = '''«integersInProblem»''' it.value = integersInProblem it.valueSet = true]

-                        }

-                        if(maxNewIntegers>0) {

-                                it.openWorldElementPrototypes += createIntegerElement => [it.name = "Symbolic New Integer" it.valueSet = false]

-                        }

-                        

-                        // Reals

-                        it.maxNewReals = typeScopes.maxNewReals

-                        val knownReals = (typeScopes.knownReals + problem.eAllContents.toIterable.filter(RealLiteral).map[value]).toSet

-                        for(realsInProblem : knownReals) {

-                                it.realelements += createRealElement => [it.name = '''«realsInProblem»''' it.value = realsInProblem it.valueSet = true]

-                        }

-                        if(maxNewReals>0) {

-                                it.openWorldElementPrototypes += createRealElement => [it.name = "Symbolic New Real" it.valueSet = false]

-                        }

-                        

-                        // Strings

-                        it.maxNewStrings = typeScopes.maxNewStrings

-                        val knownStrings = (typeScopes.knownStrings + problem.eAllContents.toIterable.filter(StringLiteral).map[value]).toSet

-                        for(stringsInProblem : knownStrings) {

-                                it.stringelement += createStringElement => [it.name = '''"«stringsInProblem»"''' it.value=stringsInProblem it.valueSet = true]

-                        }

-                        if(maxNewStrings>0) {

-                                it.openWorldElementPrototypes += createStringElement => [it.name = "Symbolic New String" it.valueSet = false]

-                        }

-                        

-                        for(typeDeclaration : problem.types.filter(TypeDeclaration)) {

-                                it.partialtypeinterpratation += typeDeclaration.initialisePartialTypeInterpretation(engine,trace)

-                        }

-                        problem.connectSuperypes(trace)

-                                                

-                        it.partialrelationinterpretation += problem.relations.filter(RelationDeclaration)

-                                .map[initialisePartialRelationInterpretation(trace)]

-                        for(pMR2A : problem.annotations.filter(PartialModelRelation2Assertion)) {

-                                val relation = pMR2A.targetRelation

-                                val interpretation = relation.lookup(trace.relation2Interpretation)

-                                interpretation.relationlinks+=pMR2A.links.map[EcoreUtil.copy(it)]

-                        }

-                        it.partialfunctioninterpretation += problem.functions.filter(FunctionDeclaration)

-                                .map[initialisePartialFunctionInterpretation(trace)]

-                        it.partialconstantinterpretation += problem.constants.filter(ConstantDeclaration)

-                                .map[initialisePartialConstantDeclaration(trace)]

+                        // Initialise relations

+                        initRelations(it,trace)

                 ]

                 

                 return new TracedOutput(res,trace)

         }

         

-        /**

-         * Initialize type with existing elements

-         */

-        def private initialisePartialTypeInterpretation(TypeDeclaration t, ViatraQueryEngine engine, Problem2PartialInterpretationTrace trace) {

-                val supertypeMatcher = SupertypeStar.Matcher.on(engine)

-                val res = createPartialTypeInterpratation => [

-                        it.interpretationOf = t

-                        it.elements += supertypeMatcher.getAllValuesOfsubtype(t)

-                                .filter(TypeDefinition)

-                                .map[elements].flatten

-                ]

-                trace.type2Interpretation.put(t,res)

-                return res

+        def protected boolean initBooleans(PartialInterpretation partialInterpretation) {

+                val booleanInterpretation = createPartialBooleanInterpretation

+                partialInterpretation.partialtypeinterpratation += booleanInterpretation

+                

+                val trueElement = createBooleanElement => [it.name = "true" it.value = true it.valueSet = true]

+                booleanInterpretation.elements += trueElement

+                partialInterpretation.newElements+=trueElement

+                

+                val falseElement = createBooleanElement => [it.name = "false" it.value = false it.valueSet = true]

+                booleanInterpretation.elements += falseElement

+                partialInterpretation.newElements+=falseElement

+        }

+        

+        def protected initIntegers(PartialInterpretation partialInterpretation, SortedSet<Integer> knownIntegers, int minNewIntegers, int maxNewIntegers) {

+                val integerInterpretation = createPartialIntegerInterpretation

+                partialInterpretation.partialtypeinterpratation += integerInterpretation

+                

+                for(knownInteger : knownIntegers) {

+                        val integerElement = createIntegerElement => [it.name = knownInteger.toString it.value = knownInteger it.valueSet = true]

+                        integerInterpretation.elements += integerElement

+                        partialInterpretation.newElements += integerElement

+                }

+                if(maxNewIntegers>0) {

+                        throw new UnsupportedOperationException('''Unspecified Integers are currently not supported!''')

+                }

+        }

+        

+        def protected initReals(PartialInterpretation partialInterpretation, SortedSet<BigDecimal> knownReals, int minNewReals, int maxNewReals) {

+                val realInterpretation = createPartialRealInterpretation

+                partialInterpretation.partialtypeinterpratation += realInterpretation

+                

+                for(knownReal : knownReals) {

+                        val realElement = createRealElement => [it.name = knownReal.toString it.value = knownReal it.valueSet = true]

+                        realInterpretation.elements += realElement

+                        partialInterpretation.newElements += realElement

+                }

+                if(maxNewReals>0) {

+                        throw new UnsupportedOperationException('''Unspecified Real values are currently not supported!''')

+                }

+        }

+        

+        def protected initStrings(PartialInterpretation partialInterpretation, SortedSet<String> knownStrings, int minNewStrings, int maxNewStrings) {

+                val stringInterpretation = createPartialStringInterpretation

+                partialInterpretation.partialtypeinterpratation += stringInterpretation

+                

+                for(knownString : knownStrings) {

+                        val stringElement = createStringElement => [it.name = '''"«knownString»"''' it.value = knownString it.valueSet = true]

+                        stringInterpretation.elements += stringElement

+                        partialInterpretation.newElements += stringElement

+                }

+                if(maxNewStrings>0) {

+                        throw new UnsupportedOperationException('''Unspecified String values are currently not supported!''')

+                }

+        }

+        

+        def protected initElements(PartialInterpretation interpretation,

+                Map<Type, Integer> minNewElementsByType, Map<Type, Integer> maxNewElementsByType,

+                int minNewElements, int maxNewElements,

+                Problem2PartialInterpretationTrace trace)

+        {

+                val engine = ViatraQueryEngine.on(new EMFScope(interpretation.problem))

+                // Elements

+                interpretation.minNewElements = minNewElements

+                interpretation.maxNewElements = maxNewElements

+                // elements from problem are included

+                if(maxNewElements>0) {

+                        val newElements = createDefinedElement => [it.name = "New Objects"]

+                        interpretation.openWorldElements += newElements 

+                }

+                

+                for(typeDeclaration : interpretation.problem.types.filter(TypeDeclaration)) {

+                        val typeInterpretation = typeDeclaration.initialisePartialTypeInterpretation(engine,trace)

+                        interpretation.partialtypeinterpratation += typeInterpretation

+                }

+                interpretation.problem.connectSuperypes(trace)

         }

         

         def private connectSuperypes(LogicProblem problem, Problem2PartialInterpretationTrace trace) {

@@ -140,6 +162,32 @@ class PartialInterpretationInitialiser {
                 }

         }

         

+        def private initRelations(PartialInterpretation interpretation, Problem2PartialInterpretationTrace trace) {

+                interpretation.partialrelationinterpretation += interpretation.problem.relations.filter(RelationDeclaration)

+                        .map[initialisePartialRelationInterpretation(trace)]

+                for(pMR2A : interpretation.problem.annotations.filter(PartialModelRelation2Assertion)) {

+                        val relation = pMR2A.targetRelation

+                        val r = relation.lookup(trace.relation2Interpretation)

+                        r.relationlinks+=pMR2A.links.map[EcoreUtil.copy(it)]

+                }

+//              interpretation.partialfunctioninterpretation += interpretation.problem.functions.filter(FunctionDeclaration)

+//                      .map[initialisePartialFunctionInterpretation(trace)]

+//              interpretation.partialconstantinterpretation += interpretation.problem.constants.filter(ConstantDeclaration)

+//                      .map[initialisePartialConstantDeclaration(trace)]

+        }

+        

+        def private initialisePartialTypeInterpretation(TypeDeclaration t, ViatraQueryEngine engine, Problem2PartialInterpretationTrace trace) {

+                val supertypeMatcher = SupertypeStar.Matcher.on(engine)

+                val res = createPartialComplexTypeInterpretation => [

+                        it.interpretationOf = t

+                        it.elements += supertypeMatcher.getAllValuesOfsubtype(t)

+                                .filter(TypeDefinition)

+                                .map[elements].flatten

+                ]

+                trace.type2Interpretation.put(t,res)

+                return res

+        }

+        

         def private initialisePartialRelationInterpretation(RelationDeclaration r, Problem2PartialInterpretationTrace trace) {

                 val res = createPartialRelationInterpretation => [

                         it.interpretationOf = r

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
index a5739edf..bf593add 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
@@ -13,6 +13,8 @@ import java.util.Map
 import java.util.Set

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 

 abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresentation,NodeRepresentation> {

         private val boolean deepRepresentation

@@ -33,6 +35,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
          * @param model The model to be represented.

          * @param range The range of the neighbourhood.

          * @param parallels The maximal number of parallel references to be differentiated.

+         * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated.

          */

         def public createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber) {

                 return createRepresentation(model,range,parallels,maxNumber,null,null)

@@ -187,10 +190,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                 return

                         model.problem.elements +

                         model.newElements +

-                        model.booleanelements+

-                        model.integerelements+

-                        model.stringelement+

-                        model.realelements

+                        model.openWorldElements

         }

         

         def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type, Set<TypeDeclaration> relevantTypes) {

@@ -202,10 +202,14 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
 //                      // Dont need

 //              }

                 for(typeInterpretation : model.partialtypeinterpratation) {

-                        val type = typeInterpretation.interpretationOf

-                        if(type.isRelevant(relevantTypes)) {

-                                for(element : typeInterpretation.elements) {

-                                        element.lookup(node2Type).add(type.name)

+                        if(typeInterpretation instanceof PartialPrimitiveInterpretation) {

+                                

+                        } else if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                                val type = typeInterpretation.interpretationOf

+                                if(type.isRelevant(relevantTypes)) {

+                                        for(element : typeInterpretation.elements) {

+                                                element.lookup(node2Type).add(type.name)

+                                        }

                                 }

                         }

                 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend
index c421ace6..f55a501a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend
@@ -18,6 +18,8 @@ import org.eclipse.viatra.dse.statecode.IStateCoderFactory
 import org.eclipse.viatra.query.runtime.api.IPatternMatch

 import org.eclipse.xtend.lib.annotations.Accessors

 import org.eclipse.xtend.lib.annotations.Data

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 

 class IdentifierBasedStateCoderFactory implements IStateCoderFactory{

         

@@ -116,7 +118,13 @@ class IdentifierBasedStateCoder implements IStateCoder{
                 } else if(element instanceof PartialRelationInterpretation) {

                         return element.interpretationOf.name.hashCode

                 } else if(element instanceof PartialTypeInterpratation) {

-                        return element.interpretationOf.name.hashCode

+                        if(element instanceof PartialPrimitiveInterpretation) {

+                                element.class.simpleName.hashCode

+                        } else if (element instanceof PartialComplexTypeInterpretation){

+                                return element.interpretationOf.name.hashCode

+                        } else {

+                                throw new UnsupportedOperationException('''Unsupported type: «element.class.simpleName»''')

+                        }

                 } else {

                         println(element)

                         throw new UnsupportedOperationException('''Unsupported type: «element.class.simpleName»''')

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
index 5fb85b0c..65a8207e 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
@@ -30,6 +30,8 @@ import java.util.Set
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2NeighbourhoodRepresentation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
 
 class NeighbourhoodBasedStateCoderFactory implements IStateCoderFactory {
         val List<NeighbourhoodBasedPartialInterpretationStateCoder> statecoders = new LinkedList
@@ -142,7 +144,13 @@ class NeighbourhoodBasedPartialInterpretationStateCoder implements IStateCoder{
                 } else if(o instanceof PartialRelationInterpretation) {
                         return o.interpretationOf.name
                 } else if(o instanceof PartialTypeInterpratation) {
-                        return o.interpretationOf.name
+                        if(o instanceof PartialPrimitiveInterpretation) {
+                                o.class.simpleName.hashCode
+                        } else if (o instanceof PartialComplexTypeInterpretation){
+                                return o.interpretationOf.name.hashCode
+                        } else {
+                                throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''')
+                        }
                 } else {
                         throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''')
                 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
index 6e948827..2b42a8b1 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
@@ -1,14 +1,15 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation

 

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

-import java.util.Map

-import java.util.HashMap

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

+import java.util.HashMap

+import java.util.Map

 import java.util.Set

 

 class PartialInterpretation2Gml {

@@ -16,10 +17,7 @@ class PartialInterpretation2Gml {
                 return

                         model.problem.elements +

                         model.newElements +

-                        model.booleanelements+

-                        model.integerelements+

-                        model.stringelement+

-                        model.realelements

+                        model.openWorldElements

         }

         

         def public transform(PartialInterpretation i) {

@@ -41,8 +39,9 @@ class PartialInterpretation2Gml {
                 '''.toString

         }

         def typesOfElement(DefinedElement e, PartialInterpretation i) {

-                i.problem.types.filter(TypeDefinition).filter[it.elements.contains(e)] +

-                i.partialtypeinterpratation.filter[it.elements.contains(e)].map[it.interpretationOf]

+                val typesElementDefinedIn= i.problem.types.filter(TypeDefinition).filter[it.elements.contains(e)]

+                val typesElementAddedDuringGeneration = i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation).filter[it.elements.contains(e)].map[it.interpretationOf]

+                return typesElementDefinedIn+typesElementAddedDuringGeneration

         }

         

         val protected titleSize = 16

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
index 7751c8eb..eef53973 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
@@ -10,9 +10,9 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BooleanElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.IntegerElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PrimitiveElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RealElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.StringElement

@@ -20,16 +20,16 @@ import java.math.BigDecimal
 import java.util.HashMap

 import java.util.List

 import java.util.Map

+import java.util.TreeSet

 import org.eclipse.emf.ecore.EObject

 import org.eclipse.xtext.xbase.lib.Functions.Function1

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import java.util.TreeSet

 

 class PartialModelAsLogicInterpretation implements LogicModelInterpretation{

         val PartialInterpretation partialInterpretation

         val Map<EObject, EObject> trace;

-        val Map<TypeDeclaration,PartialTypeInterpratation> type2Interpretation

+        val Map<TypeDeclaration,PartialComplexTypeInterpretation> type2Interpretation

         val Map<RelationDeclaration,PartialRelationInterpretation> relation2Interpretation

         

         val Map<DefinedElement,DefinedElement> elementBackwardTrace

@@ -41,18 +41,18 @@ class PartialModelAsLogicInterpretation implements LogicModelInterpretation{
         new(PartialInterpretation partialInterpretation, Map<EObject, EObject> forwardMap) {

                 this.partialInterpretation = partialInterpretation

                 this.trace = forwardMap

-                this.type2Interpretation = initTypes(partialInterpretation.partialtypeinterpratation)

+                this.type2Interpretation = initComplexTypes(partialInterpretation.partialtypeinterpratation.filter(PartialComplexTypeInterpretation))

                 this.relation2Interpretation = initRelations(partialInterpretation.partialrelationinterpretation)

                 

                 this.elementBackwardTrace = initElementBackwardTrace(trace)

                 this.booleanForwardTrace = initialisePrimitiveElementTrace(

-                        null,null,[null],partialInterpretation.booleanelements,[it.value])

+                        null,null,[null],partialInterpretation.newElements.filter(BooleanElement),[it.value])

                 integerForwardTrace = initialisePrimitiveElementTrace(

-                        0,[it+1],[it],partialInterpretation.integerelements,[it.value])

+                        0,[it+1],[it],partialInterpretation.newElements.filter(IntegerElement),[it.value])

                 realForwardTrace = initialisePrimitiveElementTrace(

-                        BigDecimal::ZERO,[it.add(BigDecimal.ONE)],[it],partialInterpretation.realelements,[it.value])

+                        BigDecimal::ZERO,[it.add(BigDecimal.ONE)],[it],partialInterpretation.newElements.filter(RealElement),[it.value])

                 stringForwardTrace = initialisePrimitiveElementTrace(

-                        0,[it+1],['''String«it»'''],partialInterpretation.stringelement,[it.value])

+                        0,[it+1],['''String«it»'''],partialInterpretation.newElements.filter(StringElement),[it.value])

         }

         

         private def <Seed,Type,ElementType extends PrimitiveElement> Map<Type,ElementType> initialisePrimitiveElementTrace(

@@ -83,7 +83,7 @@ class PartialModelAsLogicInterpretation implements LogicModelInterpretation{
                 return forwardMap

         }

         

-        def initTypes(List<PartialTypeInterpratation> types) {

+        def initComplexTypes(Iterable<PartialComplexTypeInterpretation> types) {

                 types.toMap[it.interpretationOf]

         }

         def initRelations(List<PartialRelationInterpretation> relations) {

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend
index e30b27ac..78326207 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend
@@ -10,11 +10,15 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BooleanElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.IntegerElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RealElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.StringElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualiser

 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace

-import java.util.Collection

 import java.util.HashMap

 import java.util.HashSet

 import java.util.LinkedList

@@ -45,10 +49,7 @@ class GraphvizVisualiser implements PartialInterpretationVisualiser {
                 return

                         model.problem.elements +

                         model.newElements +

-                        model.booleanelements+

-                        model.integerelements+

-                        model.stringelement+

-                        model.realelements

+                        model.openWorldElements

         }

         

         def private visualisePartialInterpretation(PartialInterpretation partialInterpretation, boolean concretizationOnly) {

@@ -72,7 +73,7 @@ class GraphvizVisualiser implements PartialInterpretationVisualiser {
                                 mustTypes.get(element)+=typeDefinition

                         }

                 }

-                for(partialTypeInterpretations: partialInterpretation.partialtypeinterpratation) {

+                for(partialTypeInterpretations: partialInterpretation.partialtypeinterpratation.filter(PartialComplexTypeInterpretation)) {

                         for(element : partialTypeInterpretations.elements) {

                                 mustTypes.get(element)+=partialTypeInterpretations.interpretationOf

                         }

@@ -105,10 +106,10 @@ class GraphvizVisualiser implements PartialInterpretationVisualiser {
 //                      elements2Node.put(newElement,image)

 //              }

                 

-                partialInterpretation.booleanelements.drawDataTypes([it.value.toString],elements2Node,elements2ID)

-                partialInterpretation.integerelements.drawDataTypes([it.value.toString],elements2Node,elements2ID)

-                partialInterpretation.stringelement.drawDataTypes(['''"«it.value.toString»"'''],elements2Node,elements2ID)

-                partialInterpretation.realelements.drawDataTypes([it.value.toString],elements2Node,elements2ID)

+                partialInterpretation.newElements.filter(BooleanElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

+                partialInterpretation.newElements.filter(IntegerElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

+                partialInterpretation.newElements.filter(StringElement).drawDataTypes(['''"«it.value.toString»"'''],elements2Node,elements2ID)

+                partialInterpretation.newElements.filter(RealElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

                 

                 // Drawing the edges

                 val edges = new HashMap

@@ -134,7 +135,7 @@ class GraphvizVisualiser implements PartialInterpretationVisualiser {
                 return new GraphvizVisualisation(graph)

         }

         

-        def protected <T extends DefinedElement> void drawDataTypes(Collection<T> collection, Function1<T,String> namer, HashMap<DefinedElement, Node> elements2Node, HashMap<DefinedElement, String> elements2ID) {

+        def protected <T extends DefinedElement> void drawDataTypes(Iterable<T> collection, Function1<T,String> namer, HashMap<DefinedElement, Node> elements2Node, HashMap<DefinedElement, String> elements2ID) {

                 for(booleanElementIndex: 0..<collection.size) {

                         val newElement = collection.get(booleanElementIndex)

                         val id = namer.apply(newElement)