Migrating Additional projects

author: OszkarSemerath <oszka@152.66.252.189> 2017-06-10 19:05:05 +0200
committer: OszkarSemerath <oszka@152.66.252.189> 2017-06-10 19:05:05 +0200
commit: 60f01f46ba232ed6416054f0a6115cb2a9b70b4e (patch)
tree: 5edf8aeb07abc51f3fec63bbd15c926e1de09552 /Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
parent: Initial commit, migrating from SVN (diff)
download: VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.gz
VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.zst
VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.zip
1 files changed, 209 insertions, 0 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
new file mode 100644
index 00000000..8b0f8f85
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
@@ -0,0 +1,209 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ObjectCreationPrecondition
+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.util.LinkedHashMap
+import org.eclipse.viatra.query.runtime.api.GenericPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory
+class RefinementRuleProvider {
+        private extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory
+        private extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE
+        private extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE
+        
+        def canonizeName(String name) {
+                return name.replace(' ','_')
+        }
+        
+        def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> 
+                createObjectRefinementRules(
+                        GeneratedPatterns patterns,
+                        boolean nameNewElement,
+                        ModelGenerationStatistics statistics
+                )
+        {               
+                val res = new LinkedHashMap
+                for(LHSEntry: patterns.refineObjectQueries.entrySet) {
+                        val containmentRelation = LHSEntry.key.containmentRelation
+                        val inverseRelation = LHSEntry.key.inverseContainment
+                        val type = LHSEntry.key.newType
+                        val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>
+                        val rule = createObjectCreationRule(containmentRelation,inverseRelation,type,lhs,nameNewElement,statistics)
+                        res.put(LHSEntry.key,rule)
+                }
+                return res
+        }
+        
+        def private createObjectCreationRule(
+                Relation containmentRelation,
+                Relation inverseRelation,
+                Type type,
+                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs,
+                boolean nameNewElement,
+                ModelGenerationStatistics statistics)
+        {
+                val name = '''addObject_«type.name.canonizeName»«
+                                        IF containmentRelation!=null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''
+                val ruleBuilder = factory.createRule
+                                .name(name)
+                                .precondition(lhs)
+                if(containmentRelation != null) {
+                        if(inverseRelation!= null) {
+                                ruleBuilder.action[match |
+                                        //println(name)
+                                        val startTime = System.nanoTime
+                                        //val problem = match.get(0) as LogicProblem
+                                        val interpretation = match.get(1) as PartialInterpretation
+                                        val relationInterpretation = match.get(2) as PartialRelationInterpretation
+                                        val inverseRelationInterpretation = match.get(3) as PartialRelationInterpretation
+                                        val typeInterpretation = match.get(4) as PartialTypeInterpratation
+                                        val container = match.get(5) as DefinedElement
+                                        
+                                        val newElement = createDefinedElement
+                                        if(nameNewElement) {
+                                                newElement.name = '''new «interpretation.newElements.size»'''
+                                        }
+                                        
+                                        // Existence
+                                        interpretation.newElements+=newElement
+                                        interpretation.maxNewElements=interpretation.maxNewElements-1
+                                        if(interpretation.minNewElements > 0) {
+                                                interpretation.minNewElements=interpretation.minNewElements-1
+                                        }
+                                        
+                                        // Types
+                                        typeInterpretation.elements += newElement
+                                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]
+                                        // ContainmentRelation
+                                        val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]
+                                        relationInterpretation.relationlinks+=newLink1
+                                        // Inverse Containment
+                                        val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container]
+                                        inverseRelationInterpretation.relationlinks+=newLink2
+                                        statistics.addExecutionTime(System.nanoTime-startTime)
+                                ]
+                        } else {
+                                ruleBuilder.action[match |
+                                        //println(name)
+                                        val startTime = System.nanoTime
+                                        //val problem = match.get(0) as LogicProblem
+                                        val interpretation = match.get(1) as PartialInterpretation
+                                        val relationInterpretation = match.get(2) as PartialRelationInterpretation
+                                        val typeInterpretation = match.get(3) as PartialTypeInterpratation
+                                        val container = match.get(4) as DefinedElement
+                                        
+                                        val newElement = createDefinedElement
+                                        if(nameNewElement) {
+                                                newElement.name = '''new «interpretation.newElements.size»'''
+                                        }
+                                        
+                                        // Existence
+                                        interpretation.newElements+=newElement
+                                        interpretation.maxNewElements=interpretation.maxNewElements-1
+                                        if(interpretation.minNewElements > 0) {
+                                                interpretation.minNewElements=interpretation.minNewElements-1
+                                        }
+                                        
+                                        // Types
+                                        typeInterpretation.elements += newElement
+                                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]
+                                        // ContainmentRelation
+                                        val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]
+                                        relationInterpretation.relationlinks+=newLink
+                                        statistics.addExecutionTime(System.nanoTime-startTime)
+                                ]
+                        }
+                } else {
+                        ruleBuilder.action[match |
+                                //println(name)
+                                val startTime = System.nanoTime
+                                //val problem = match.get(0) as LogicProblem
+                                val interpretation = match.get(1) as PartialInterpretation
+                                val typeInterpretation = match.get(2) as PartialTypeInterpratation
+                                
+                                val newElement = createDefinedElement //=> [it.name = null]
+                                if(nameNewElement) {
+                                        newElement.name = '''new «interpretation.newElements.size»'''
+                                }
+                                // Existence
+                                interpretation.newElements+=newElement
+                                interpretation.maxNewElements=interpretation.maxNewElements-1
+                                if(interpretation.minNewElements > 0) {
+                                        interpretation.minNewElements=interpretation.minNewElements-1
+                                }
+                                // Types
+                                typeInterpretation.elements += newElement
+                                typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]
+                                statistics.addExecutionTime(System.nanoTime-startTime)
+                        ]
+                }
+                return ruleBuilder.build
+        }
+        
+        def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) {
+                val res = new LinkedHashMap
+                for(LHSEntry: patterns.refinerelationQueries.entrySet) {
+                        val declaration = LHSEntry.key.key
+                        val inverseReference = LHSEntry.key.value
+                        val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>
+                        val rule = createRelationRefinementRule(declaration,inverseReference,lhs,statistics)
+                        res.put(LHSEntry.key,rule)
+                }
+                return res
+        }
+        
+        def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>
+                createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ModelGenerationStatistics statistics)
+        {
+                val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation != null»_and_«inverseRelation.name.canonizeName»«ENDIF»'''
+                val ruleBuilder = factory.createRule
+                        .name(name)
+                        .precondition(lhs)
+                if (inverseRelation == null) {
+                        ruleBuilder.action [ match |
+                            val startTime = System.nanoTime
+                                //println(name)
+                                // val problem = match.get(0) as LogicProblem
+                                // val interpretation = match.get(1) as PartialInterpretation
+                                val relationInterpretation = match.get(2) as PartialRelationInterpretation
+                                val src = match.get(3) as DefinedElement
+                                val trg = match.get(4) as DefinedElement
+                                val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]
+                                relationInterpretation.relationlinks += link
+                statistics.addExecutionTime(System.nanoTime-startTime)
+                        ]
+                } else {
+                        ruleBuilder.action [ match |
+                            val startTime = System.nanoTime
+                                //println(name)
+                                // val problem = match.get(0) as LogicProblem
+                                // val interpretation = match.get(1) as PartialInterpretation
+                                val relationInterpretation = match.get(2) as PartialRelationInterpretation
+                                val inverseInterpretation = match.get(3) as PartialRelationInterpretation
+                                val src = match.get(4) as DefinedElement
+                                val trg = match.get(5) as DefinedElement
+                                val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]
+                                relationInterpretation.relationlinks += link
+                                val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src]
+                                inverseInterpretation.relationlinks += inverseLink
+                                statistics.addExecutionTime(System.nanoTime-startTime)
+                        ]
+                }
+                return ruleBuilder.build
+        }
+}
author	OszkarSemerath <oszka@152.66.252.189>	2017-06-10 19:05:05 +0200
committer	OszkarSemerath <oszka@152.66.252.189>	2017-06-10 19:05:05 +0200
commit	60f01f46ba232ed6416054f0a6115cb2a9b70b4e (patch)
tree	5edf8aeb07abc51f3fec63bbd15c926e1de09552 /Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
parent	Initial commit, migrating from SVN (diff)
download	VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.gz VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.zst VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.zip

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend new file mode 100644 index 00000000..8b0f8f85 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
@@ -0,0 +1,209 @@
	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
	2
	3	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
	4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory
	5	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
	6	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
	7	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
	8	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
	9	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
	10	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
	11	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ObjectCreationPrecondition
	12	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
	13	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation
	14	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation
	15	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory
	16	import java.util.LinkedHashMap
	17	import org.eclipse.viatra.query.runtime.api.GenericPatternMatch
	18	import org.eclipse.viatra.query.runtime.api.IQuerySpecification
	19	import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
	20	import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule
	21	import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory
	22
	23	class RefinementRuleProvider {
	24	private extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory
	25	private extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE
	26	private extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE
	27
	28	def canonizeName(String name) {
	29	return name.replace(' ','_')
	30	}
	31
	32	def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>>
	33	createObjectRefinementRules(
	34	GeneratedPatterns patterns,
	35	boolean nameNewElement,
	36	ModelGenerationStatistics statistics
	37	)
	38	{
	39	val res = new LinkedHashMap
	40	for(LHSEntry: patterns.refineObjectQueries.entrySet) {
	41	val containmentRelation = LHSEntry.key.containmentRelation
	42	val inverseRelation = LHSEntry.key.inverseContainment
	43	val type = LHSEntry.key.newType
	44	val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>
	45	val rule = createObjectCreationRule(containmentRelation,inverseRelation,type,lhs,nameNewElement,statistics)
	46	res.put(LHSEntry.key,rule)
	47	}
	48	return res
	49	}
	50
	51	def private createObjectCreationRule(
	52	Relation containmentRelation,
	53	Relation inverseRelation,
	54	Type type,
	55	IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs,
	56	boolean nameNewElement,
	57	ModelGenerationStatistics statistics)
	58	{
	59	val name = '''addObject_«type.name.canonizeName»«
	60	IF containmentRelation!=null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''
	61	val ruleBuilder = factory.createRule
	62	.name(name)
	63	.precondition(lhs)
	64	if(containmentRelation != null) {
	65	if(inverseRelation!= null) {
	66	ruleBuilder.action[match \|
	67	//println(name)
	68	val startTime = System.nanoTime
	69	//val problem = match.get(0) as LogicProblem
	70	val interpretation = match.get(1) as PartialInterpretation
	71	val relationInterpretation = match.get(2) as PartialRelationInterpretation
	72	val inverseRelationInterpretation = match.get(3) as PartialRelationInterpretation
	73	val typeInterpretation = match.get(4) as PartialTypeInterpratation
	74	val container = match.get(5) as DefinedElement
	75
	76	val newElement = createDefinedElement
	77	if(nameNewElement) {
	78	newElement.name = '''new «interpretation.newElements.size»'''
	79	}
	80
	81	// Existence
	82	interpretation.newElements+=newElement
	83	interpretation.maxNewElements=interpretation.maxNewElements-1
	84	if(interpretation.minNewElements > 0) {
	85	interpretation.minNewElements=interpretation.minNewElements-1
	86	}
	87
	88	// Types
	89	typeInterpretation.elements += newElement
	90	typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]
	91	// ContainmentRelation
	92	val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]
	93	relationInterpretation.relationlinks+=newLink1
	94	// Inverse Containment
	95	val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container]
	96	inverseRelationInterpretation.relationlinks+=newLink2
	97	statistics.addExecutionTime(System.nanoTime-startTime)
	98	]
	99	} else {
	100	ruleBuilder.action[match \|
	101	//println(name)
	102	val startTime = System.nanoTime
	103	//val problem = match.get(0) as LogicProblem
	104	val interpretation = match.get(1) as PartialInterpretation
	105	val relationInterpretation = match.get(2) as PartialRelationInterpretation
	106	val typeInterpretation = match.get(3) as PartialTypeInterpratation
	107	val container = match.get(4) as DefinedElement
	108
	109	val newElement = createDefinedElement
	110	if(nameNewElement) {
	111	newElement.name = '''new «interpretation.newElements.size»'''
	112	}
	113
	114	// Existence
	115	interpretation.newElements+=newElement
	116	interpretation.maxNewElements=interpretation.maxNewElements-1
	117	if(interpretation.minNewElements > 0) {
	118	interpretation.minNewElements=interpretation.minNewElements-1
	119	}
	120
	121	// Types
	122	typeInterpretation.elements += newElement
	123	typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]
	124	// ContainmentRelation
	125	val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]
	126	relationInterpretation.relationlinks+=newLink
	127	statistics.addExecutionTime(System.nanoTime-startTime)
	128	]
	129	}
	130	} else {
	131	ruleBuilder.action[match \|
	132	//println(name)
	133	val startTime = System.nanoTime
	134	//val problem = match.get(0) as LogicProblem
	135	val interpretation = match.get(1) as PartialInterpretation
	136	val typeInterpretation = match.get(2) as PartialTypeInterpratation
	137
	138	val newElement = createDefinedElement //=> [it.name = null]
	139	if(nameNewElement) {
	140	newElement.name = '''new «interpretation.newElements.size»'''
	141	}
	142	// Existence
	143	interpretation.newElements+=newElement
	144	interpretation.maxNewElements=interpretation.maxNewElements-1
	145	if(interpretation.minNewElements > 0) {
	146	interpretation.minNewElements=interpretation.minNewElements-1
	147	}
	148	// Types
	149	typeInterpretation.elements += newElement
	150	typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]
	151	statistics.addExecutionTime(System.nanoTime-startTime)
	152	]
	153	}
	154	return ruleBuilder.build
	155	}
	156
	157	def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) {
	158	val res = new LinkedHashMap
	159	for(LHSEntry: patterns.refinerelationQueries.entrySet) {
	160	val declaration = LHSEntry.key.key
	161	val inverseReference = LHSEntry.key.value
	162	val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>
	163	val rule = createRelationRefinementRule(declaration,inverseReference,lhs,statistics)
	164	res.put(LHSEntry.key,rule)
	165	}
	166	return res
	167	}
	168
	169	def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>
	170	createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ModelGenerationStatistics statistics)
	171	{
	172	val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation != null»_and_«inverseRelation.name.canonizeName»«ENDIF»'''
	173	val ruleBuilder = factory.createRule
	174	.name(name)
	175	.precondition(lhs)
	176	if (inverseRelation == null) {
	177	ruleBuilder.action [ match \|
	178	val startTime = System.nanoTime
	179	//println(name)
	180	// val problem = match.get(0) as LogicProblem
	181	// val interpretation = match.get(1) as PartialInterpretation
	182	val relationInterpretation = match.get(2) as PartialRelationInterpretation
	183	val src = match.get(3) as DefinedElement
	184	val trg = match.get(4) as DefinedElement
	185	val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]
	186	relationInterpretation.relationlinks += link
	187	statistics.addExecutionTime(System.nanoTime-startTime)
	188	]
	189	} else {
	190	ruleBuilder.action [ match \|
	191	val startTime = System.nanoTime
	192	//println(name)
	193	// val problem = match.get(0) as LogicProblem
	194	// val interpretation = match.get(1) as PartialInterpretation
	195	val relationInterpretation = match.get(2) as PartialRelationInterpretation
	196	val inverseInterpretation = match.get(3) as PartialRelationInterpretation
	197	val src = match.get(4) as DefinedElement
	198	val trg = match.get(5) as DefinedElement
	199	val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]
	200	relationInterpretation.relationlinks += link
	201	val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src]
	202	inverseInterpretation.relationlinks += inverseLink
	203	statistics.addExecutionTime(System.nanoTime-startTime)
	204	]
	205	}
	206
	207	return ruleBuilder.build
	208	}
	209	}