Add patterns to shape

3 files changed, 48 insertions, 30 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
index 2e8f61a9..f9cf2986 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
@@ -5,6 +5,7 @@ import java.util.Map
 import java.util.Set

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

 import java.util.List

+import java.util.HashSet

 

 @Data abstract class AbstractNodeDescriptor {

         long dataHash

@@ -25,10 +26,11 @@ import java.util.List
 //      }

 }

 

-//TODO: Modify for patterns

+

 @Data class LocalNodeDescriptor extends AbstractNodeDescriptor{

         Set<String> types

         String id;

+

         new(String id, Set<String> types) {

                 super(calcualteDataHash(id,types))

                 this.types = types

@@ -89,8 +91,6 @@ import java.util.List
 //      }

 }

 

-//TODO: PatternRelation

-

 @Data class PatternRelation<NODESHAPE> {

         String patternName

         int param

@@ -107,28 +107,31 @@ import java.util.List
         String type

 }

 

-//TODO: Modify for hypergraphs

 @Data class FurtherNodeDescriptor<NodeRep> extends AbstractNodeDescriptor{

         

          NodeRep previousRepresentation

          Map<IncomingRelation<NodeRep>,Integer> incomingEdges

          Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges

+         Set<PatternRelation<NodeRep>> patterns

          

          new(

                 NodeRep previousRepresentation,

                 Map<IncomingRelation<NodeRep>,Integer> incomingEdges,

-                Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges)

+                Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges,

+                Set<PatternRelation<NodeRep>> patterns)

         {

-                super(calculateDataHash(previousRepresentation,incomingEdges,outgoingEdges))

+                super(calculateDataHash(previousRepresentation,incomingEdges,outgoingEdges,patterns))

                 this.previousRepresentation = previousRepresentation

                 this.incomingEdges = new HashMap(incomingEdges)

                 this.outgoingEdges = new HashMap(outgoingEdges)

+                this.patterns=new HashSet(patterns)

          }

          

         static def private <NodeRep> int calculateDataHash(

                 NodeRep previousRepresentation,

                 Map<IncomingRelation<NodeRep>,Integer> incomingEdges,

-                Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges)

+                Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges,

+                Set<PatternRelation<NodeRep>> patterns)

         {

             val int prime = 31;

             var int result = previousRepresentation.hashCode;

@@ -136,6 +139,8 @@ import java.util.List
                         result = prime * result + incomingEdges.hashCode();

                 if(outgoingEdges !== null) 

                         result = prime * result + outgoingEdges.hashCode();

+                if (patterns !== null)

+                        result = prime * result + patterns.hashCode();

             return result;

         }

         

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend
index 22e890a2..28b936df 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/FurtherNodeDescriptorWithEquivalenceCounter.xtend
@@ -2,15 +2,17 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.ne
 

 import java.util.Map

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

+import java.util.Set

 

 class FurtherNodeDescriptorWithEquivalenceCounter extends FurtherNodeDescriptor<AbstractNodeDescriptor> {

         

         new(AbstractNodeDescriptor previousRepresentation,

                 Map<IncomingRelation<AbstractNodeDescriptor>, Integer> incomingEdges,

                 Map<OutgoingRelation<AbstractNodeDescriptor>, Integer> outgoingEdges,

-                Map<DefinedElement, FurtherNodeDescriptor<AbstractNodeDescriptor>> node2Representation)

+                Map<DefinedElement, FurtherNodeDescriptor<AbstractNodeDescriptor>> node2Representation,

+                Set<PatternRelation<AbstractNodeDescriptor>> patterns)

         {

-                super(previousRepresentation, incomingEdges, outgoingEdges)

+                super(previousRepresentation, incomingEdges, outgoingEdges, patterns)

         }

 

 }
\ No newline at end of file
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 1d26a413..e6bc5706 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
@@ -99,7 +99,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
         def Map<DefinedElement, List<PatternRelation<DefinedElement>>> createPatternRelations(

                 PartialInterpretation model, Set<ViatraQueryMatcher<? extends IPatternMatch>> relevantPatterns) {

                 val Map<DefinedElement, List<PatternRelation<DefinedElement>>> result=new HashMap;

-                if (relevantPatterns==null) return result;

+                if (relevantPatterns===null) return result;

                 for (element : model.elements) {

                         result.put(element,new LinkedList<PatternRelation<DefinedElement>>)

                 }

@@ -122,7 +122,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                 }

                                 var id=0;

                                 for (DefinedElement e:sanitizedMatch) {

-                                        if (e!=null) {

+                                        if (e!==null) {

                                                 result.get(e).add(new PatternRelation<DefinedElement>(name,id,sanitizedMatch))

                                         }

                                         id++    

@@ -132,13 +132,6 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                         println('''Ignored params '''+ignoredParams+''' of pattern '''+ name)

                 }

                 

-                /*for(relevantPattern : relevantPatterns) {

-                 *      relevantPattern.allMatches.forEach[

-                 *              it.

-                 *      ]

-                 }*/

-                

-                

                 return result;

                 

         }

@@ -222,7 +215,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                         } else if (range > 0) {

                                 val previous = doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations, PatternRelations,

                                         range - 1, parallels, maxNumber)

-                                val r = calculateFurtherNodeDescriptors(model, previous, IncomingRelations, OutgoingRelations,

+                                val r = calculateFurtherNodeDescriptors(model, previous, IncomingRelations, OutgoingRelations,PatternRelations,

                                         parallels, maxNumber)

                                 // println('''Level «range» finished.''')

                                 val res = createFurtherRepresentation(r.key, r.value, previous, deepRepresentation)

@@ -235,7 +228,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                 } else

                                         return res

                         } else if (range == FixPointRage) {

-                                return refineUntilFixpoint(model, types, IncomingRelations, OutgoingRelations, parallels, maxNumber)

+                                return refineUntilFixpoint(model, types, IncomingRelations, OutgoingRelations, PatternRelations, parallels, maxNumber)

                         } else if (range == GraphWidthRange) {

                                 val width = this.getWidth(types, IncomingRelations, OutgoingRelations)

                                 // println(width)

@@ -246,7 +239,9 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
 

                 def private refineUntilFixpoint(PartialInterpretation model, Map<DefinedElement, Set<String>> types,

                         Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                        Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels,

+                        Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

+                        Map<DefinedElement, List<PatternRelation<DefinedElement>>> PatternRelations,

+                        int parallels,

                         int maxNumbers) {

                                 var lastRange = 0

                                 val last = calculateLocalNodeDescriptors(model, types, maxNumbers)

@@ -256,7 +251,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                 do {

                                         val nextRange = lastRange + 1

                                         val next = calculateFurtherNodeDescriptors(model, lastRepresentation, IncomingRelations,

-                                                OutgoingRelations, parallels, maxNumbers)

+                                                OutgoingRelations, PatternRelations, parallels, maxNumbers)

                                         val nextRepresentation = createFurtherRepresentation(next.key, next.value, lastRepresentation,

                                                 deepRepresentation)

 

@@ -286,9 +281,9 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                         node2Type.put(element, new HashSet)

                                 }

 

-//              for(typeDefinition : model.problem.types.filter(TypeDefinition)) {

-//                      // Dont need

-//              }

+                //              for(typeDefinition : model.problem.types.filter(TypeDefinition)) {

+                //                      // Dont need

+                //              }

                                 for (typeInterpretation : model.partialtypeinterpratation) {

                                         if (typeInterpretation instanceof PartialPrimitiveInterpretation) {

                                         } else if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

@@ -328,7 +323,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                 }

 

                                 /**

-                                 * Creates a local representation of the objects (aka zero range neighbourhood)

+                                 * Creates the representation of the initial shape (aka zero range neighbourhood)

                                  */

                                 def abstract protected NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> createLocalRepresentation(

                                         Map<DefinedElement, LocalNodeDescriptor> node2Representation,

@@ -336,7 +331,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                 )

 

                                 /**

-                                 * Creates a 

+                                 * Creates the representation of a shape (aka neighbourhood) with positive range

                                  */

                                 def abstract protected NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> createFurtherRepresentation(

                                         Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> nodeDescriptors,

@@ -383,6 +378,19 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                         }

                                         return res;

                                 }

+                                

+                                private def calculatePatterns(Map<DefinedElement, List<PatternRelation<DefinedElement>>> PatternRelations,

+                                                DefinedElement object,

+                                                Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations) {

+                                                val res = new HashSet<PatternRelation<NodeRepresentation>>()

+                                                

+                                                for (patternRelation : PatternRelations.get(object)) {

+                                                        val matchshape=patternRelation.parameters.map[previousNodeRepresentations.getOrDefault(it,null)]

+                                                        res.add(new PatternRelation<NodeRepresentation>(patternRelation.patternName,patternRelation.param,matchshape))

+                                                }

+                                                

+                                                return res

+                                }

 

                                 /*def private <KEY,VALUE> void addOrCreate_Set(Map<KEY,Set<VALUE>> map, KEY key, VALUE value) {

                                  *      var Set<VALUE> s;

@@ -397,7 +405,9 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                 private def calculateFurtherNodeDescriptors(PartialInterpretation model,

                                         NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> previous,

                                         Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                                        Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels,

+                                        Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

+                                        Map<DefinedElement, List<PatternRelation<DefinedElement>>> PatternRelations,

+                                        int parallels,

                                         int maxNumber) {

                                                 val previousNodeRepresentations = previous.nodeRepresentations

                                                 val node2Representation = new HashMap<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>>

@@ -419,14 +429,15 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                                                                 previousNodeRepresentations, parallels)

                                                         val outgoingEdges = this.calcuateOutgoingEdges(OutgoingRelations, object,

                                                                 previousNodeRepresentations, parallels)

-                                                        // TODO: patternDescriptors

+                                                        val patterns = this.calculatePatterns(PatternRelations, object, previousNodeRepresentations)

+                                                        

                                                         val previousType = previousNodeRepresentations.get(object)

 

                                                         if (previousType === null) {

                                                                 println("Error in state coder")

                                                         }

 

-                                                        val nodeDescriptor = new FurtherNodeDescriptor(previousType, incomingEdges, outgoingEdges)

+                                                        val nodeDescriptor = new FurtherNodeDescriptor(previousType, incomingEdges, outgoingEdges, patterns)

 

                                                         if (this.mergeSimilarNeighbourhood) {

                                                                 if (descriptor2Number.containsKey(nodeDescriptor)) {