1 files changed, 83 insertions, 75 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
index b4403979..29d3eb61 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
@@ -1,10 +1,13 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.ImmutableSet
 import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion
 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.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import java.util.Collection
 import java.util.HashMap
 import java.util.List
 import java.util.Map
@@ -14,41 +17,40 @@ import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class RelationDeclarationIndexer {
        val PatternGenerator base;
-        
        new(PatternGenerator base) {
                this.base = base
        }
-        
-        def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations, Map<String,PQuery> fqn2PQuery) {
+        def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations,
+                Iterable<UnitPropagationPatternGenerator> unitPropagationPatternGenerators, Map<String, PQuery> fqn2PQuery) {
                val upperMultiplicities = new HashMap
-                problem.annotations.filter(UpperMultiplicityAssertion).forEach[
+                problem.annotations.filter(UpperMultiplicityAssertion).forEach [
-                        upperMultiplicities.put(it.relation,it.upper)
+                        upperMultiplicities.put(it.relation, it.upper)
                ]
-                
+                val mustNotRelations = ImmutableMap.copyOf(unitPropagationPatternGenerators.flatMap[mustNotPatterns.entrySet].
+                        groupBy[key].mapValues[ImmutableSet.copyOf(map[value])])
                return '''
-                «FOR relation : relations»
+                        «FOR relation : relations»
-                        «IF base.isDerived(relation)»
+                                «IF base.isDerived(relation)»
-                                «generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
+                                        «generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
-                                «generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
+                                        «generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
-                        «ELSE»
+                                «ELSE»
-                                «generateMustRelation(problem,relation)»
+                                        «generateMustRelation(problem, relation)»
-                                «generateMayRelation(problem,relation,upperMultiplicities,base.getContainments(problem),base.getInverseRelations(problem),fqn2PQuery)»
+                                        «generateMayRelation(problem, relation, upperMultiplicities, base.getContainments(problem), base.getInverseRelations(problem), mustNotRelations.get(relation) ?: emptySet, fqn2PQuery)»
-                        «ENDIF»
+                                «ENDIF»
-                «ENDFOR»
+                        «ENDFOR»
                '''
        }
-        
        def private patternName(RelationDeclaration r, Modality modality) {
                '''«modality.name.toLowerCase»InRelation«base.canonizeName(r.name)»'''
        }
-        
-        def referRelation(
+        def referRelation(RelationDeclaration referred, String sourceVariable, String targetVariable,
-                RelationDeclaration referred,
+                Modality modality) '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
-                String sourceVariable,
-                String targetVariable,
-                Modality modality)
-        '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
-        
        def generateMustRelation(LogicProblem problem, RelationDeclaration relation) '''
                /**
                 * Matcher for detecting tuples t where []«relation.name»(source,target)
@@ -65,59 +67,64 @@ class RelationDeclarationIndexer {
                        BinaryElementRelationLink.param2(link,target);
                }
        '''
        def generateMayRelation(LogicProblem problem, RelationDeclaration relation,
-                Map<Relation, Integer> upperMultiplicities,
+                Map<Relation, Integer> upperMultiplicities, List<Relation> containments,
-                List<Relation> containments,
+                HashMap<Relation, Relation> inverseRelations, Collection<String> mustNotRelations,
-                HashMap<Relation, Relation> inverseRelations,
+                Map<String, PQuery> fqn2PQuery) {
-                Map<String,PQuery> fqn2PQuery)
-        {
                return '''
-                /**
+                        /**
-                 * Matcher for detecting tuples t where <>«relation.name»(source,target)
+                         * Matcher for detecting tuples t where <>«relation.name»(source,target)
-                 */
+                         */
-                private pattern «relation.patternName(Modality.MAY)»(
+                        private pattern «relation.patternName(Modality.MAY)»(
-                        problem:LogicProblem, interpretation:PartialInterpretation,
+                                problem:LogicProblem, interpretation:PartialInterpretation,
-                        source: DefinedElement, target:DefinedElement)
+                                source: DefinedElement, target:DefinedElement)
-                {
+                        {
-                        find interpretation(problem,interpretation);
+                                find interpretation(problem,interpretation);
-                        // The two endpoint of the link have to exist
+                                // The two endpoint of the link have to exist
-                        find mayExist(problem, interpretation, source);
+                                find mayExist(problem, interpretation, source);
-                        find mayExist(problem, interpretation, target);
+                                find mayExist(problem, interpretation, target);
-                        // Type consistency
+                                // Type consistency
-                        «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(0),Modality.MAY,"source")»
+                                «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(0),Modality.MAY,"source")»
-                        «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(1),Modality.MAY,"target")»
+                                «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(1),Modality.MAY,"target")»
-                        «IF upperMultiplicities.containsKey(relation)»
+                                «IF upperMultiplicities.containsKey(relation)»
-                                // There are "numberOfExistingReferences" currently existing instances of the reference from the source,
+                                        // There are "numberOfExistingReferences" currently existing instances of the reference from the source,
-                                // the upper bound of the multiplicity should be considered.
+                                        // the upper bound of the multiplicity should be considered.
-                                numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»
+                                        numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»
-                                numberOfExistingReferences != «upperMultiplicities.get(relation)»;
+                                        numberOfExistingReferences != «upperMultiplicities.get(relation)»;
-                        «ENDIF»
+                                «ENDIF»
-                        «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»
+                                «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»
-                                // There are "numberOfExistingReferences" currently existing instances of the reference to the target,
+                                        // There are "numberOfExistingReferences" currently existing instances of the reference to the target,
-                                // the upper bound of the opposite reference multiplicity should be considered.
+                                        // the upper bound of the opposite reference multiplicity should be considered.
-                                numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»
+                                        numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»
-                                numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»;
+                                        numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»;
-                        «ENDIF»
+                                «ENDIF»
-                        «IF containments.contains(relation)»
+                                «IF containments.contains(relation)»
-                                // The reference is containment, then a new reference cannot be create if:
+                                        // The reference is containment, then a new reference cannot be create if:
-                                // 1. Multiple parents
+                                        // 1. Multiple parents
-                                neg «base.containmentIndexer.referMustContaint("_","target")»
+                                        neg «base.containmentIndexer.referMustContaint("_","target")»
-                                // 2. Circle in the containment hierarchy
+                                        // 2. Circle in the containment hierarchy
-                                neg «base.containmentIndexer.referTransitiveMustContains("target","source")»
+                                        neg «base.containmentIndexer.referTransitiveMustContains("target","source")»
-                        «ENDIF»
+                                «ENDIF»
-                        «IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»
+                                «IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»
-                                // The eOpposite of the reference is containment, then a referene cannot be created if
+                                        // The eOpposite of the reference is containment, then a referene cannot be created if
-                                // 1. Multiple parents
+                                        // 1. Multiple parents
-                                neg «base.containmentIndexer.referMustContaint("source","_")»
+                                        neg «base.containmentIndexer.referMustContaint("source","_")»
-                                // 2. Circle in the containment hierarchy
+                                        // 2. Circle in the containment hierarchy
-                                neg «base.containmentIndexer.referTransitiveMustContains("source","target")»
+                                        neg «base.containmentIndexer.referTransitiveMustContains("source","target")»
-                        «ENDIF»
+                                «ENDIF»
-                } or {
+                                «IF mustNotRelations.empty»
-                        «relation.referRelation("source","target",Modality.MUST)»
+                                        // ![] unit propagation relations
-                }
+                                        «FOR mustNotRelation : mustNotRelations»
-        '''
+                                                neg find «mustNotRelation»(problem, interpretation, source, target);
+                                        «ENDFOR»
+                                «ENDIF»
+                        } or {
+                                «relation.referRelation("source","target",Modality.MUST)»
+                        }
+                '''
        }
-        
        def generateDerivedMustRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''
                /**
                 * Matcher for detecting tuples t where []«relation.name»(source,target)
@@ -129,6 +136,7 @@ class RelationDeclarationIndexer {
                        «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MUST,true,false)»
                 }
        '''
        def generateDerivedMayRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''
                /**
                 * Matcher for detecting tuples t where []«relation.name»(source,target)
@@ -140,4 +148,4 @@ class RelationDeclarationIndexer {
                        «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MAY,true,false)»
                 }
        '''
-}
-\ No newline at end of file
+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend index b4403979..29d3eb61 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
@@ -1,10 +1,13 @@
1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2		2
		3	import com.google.common.collect.ImmutableMap
		4	import com.google.common.collect.ImmutableSet
3	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion	5	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion
4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation	6	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
5	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration	7	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
6	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem	8	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
7	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality	9	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
		10	import java.util.Collection
8	import java.util.HashMap	11	import java.util.HashMap
9	import java.util.List	12	import java.util.List
10	import java.util.Map	13	import java.util.Map
@@ -14,41 +17,40 @@ import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
14		17
15	class RelationDeclarationIndexer {	18	class RelationDeclarationIndexer {
16	val PatternGenerator base;	19	val PatternGenerator base;
17		20
18	new(PatternGenerator base) {	21	new(PatternGenerator base) {
19	this.base = base	22	this.base = base
20	}	23	}
21		24
22	def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations, Map<String,PQuery> fqn2PQuery) {	25	def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations,
		26	Iterable<UnitPropagationPatternGenerator> unitPropagationPatternGenerators, Map<String, PQuery> fqn2PQuery) {
23	val upperMultiplicities = new HashMap	27	val upperMultiplicities = new HashMap
24	problem.annotations.filter(UpperMultiplicityAssertion).forEach[	28	problem.annotations.filter(UpperMultiplicityAssertion).forEach [
25	upperMultiplicities.put(it.relation,it.upper)	29	upperMultiplicities.put(it.relation, it.upper)
26	]	30	]
27		31	val mustNotRelations = ImmutableMap.copyOf(unitPropagationPatternGenerators.flatMap[mustNotPatterns.entrySet].
		32	groupBy[key].mapValues[ImmutableSet.copyOf(map[value])])
		33
28	return '''	34	return '''
29	«FOR relation : relations»	35	«FOR relation : relations»
30	«IF base.isDerived(relation)»	36	«IF base.isDerived(relation)»
31	«generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»	37	«generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
32	«generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»	38	«generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
33	«ELSE»	39	«ELSE»
34	«generateMustRelation(problem,relation)»	40	«generateMustRelation(problem, relation)»
35	«generateMayRelation(problem,relation,upperMultiplicities,base.getContainments(problem),base.getInverseRelations(problem),fqn2PQuery)»	41	«generateMayRelation(problem, relation, upperMultiplicities, base.getContainments(problem), base.getInverseRelations(problem), mustNotRelations.get(relation) ?: emptySet, fqn2PQuery)»
36	«ENDIF»	42	«ENDIF»
37	«ENDFOR»	43	«ENDFOR»
38	'''	44	'''
39	}	45	}
40		46
41	def private patternName(RelationDeclaration r, Modality modality) {	47	def private patternName(RelationDeclaration r, Modality modality) {
42	'''«modality.name.toLowerCase»InRelation«base.canonizeName(r.name)»'''	48	'''«modality.name.toLowerCase»InRelation«base.canonizeName(r.name)»'''
43	}	49	}
44		50
45	def referRelation(	51	def referRelation(RelationDeclaration referred, String sourceVariable, String targetVariable,
46	RelationDeclaration referred,	52	Modality modality) '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
47	String sourceVariable,	53
48	String targetVariable,
49	Modality modality)
50	'''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
51
52	def generateMustRelation(LogicProblem problem, RelationDeclaration relation) '''	54	def generateMustRelation(LogicProblem problem, RelationDeclaration relation) '''
53	/**	55	/**
54	* Matcher for detecting tuples t where []«relation.name»(source,target)	56	* Matcher for detecting tuples t where []«relation.name»(source,target)
@@ -65,59 +67,64 @@ class RelationDeclarationIndexer {
65	BinaryElementRelationLink.param2(link,target);	67	BinaryElementRelationLink.param2(link,target);
66	}	68	}
67	'''	69	'''
		70
68	def generateMayRelation(LogicProblem problem, RelationDeclaration relation,	71	def generateMayRelation(LogicProblem problem, RelationDeclaration relation,
69	Map<Relation, Integer> upperMultiplicities,	72	Map<Relation, Integer> upperMultiplicities, List<Relation> containments,
70	List<Relation> containments,	73	HashMap<Relation, Relation> inverseRelations, Collection<String> mustNotRelations,
71	HashMap<Relation, Relation> inverseRelations,	74	Map<String, PQuery> fqn2PQuery) {
72	Map<String,PQuery> fqn2PQuery)
73	{
74	return '''	75	return '''
75	/**	76	/**
76	* Matcher for detecting tuples t where <>«relation.name»(source,target)	77	* Matcher for detecting tuples t where <>«relation.name»(source,target)
77	*/	78	*/
78	private pattern «relation.patternName(Modality.MAY)»(	79	private pattern «relation.patternName(Modality.MAY)»(
79	problem:LogicProblem, interpretation:PartialInterpretation,	80	problem:LogicProblem, interpretation:PartialInterpretation,
80	source: DefinedElement, target:DefinedElement)	81	source: DefinedElement, target:DefinedElement)
81	{	82	{
82	find interpretation(problem,interpretation);	83	find interpretation(problem,interpretation);
83	// The two endpoint of the link have to exist	84	// The two endpoint of the link have to exist
84	find mayExist(problem, interpretation, source);	85	find mayExist(problem, interpretation, source);
85	find mayExist(problem, interpretation, target);	86	find mayExist(problem, interpretation, target);
86	// Type consistency	87	// Type consistency
87	«base.typeIndexer.referInstanceOfByReference(relation.parameters.get(0),Modality.MAY,"source")»	88	«base.typeIndexer.referInstanceOfByReference(relation.parameters.get(0),Modality.MAY,"source")»
88	«base.typeIndexer.referInstanceOfByReference(relation.parameters.get(1),Modality.MAY,"target")»	89	«base.typeIndexer.referInstanceOfByReference(relation.parameters.get(1),Modality.MAY,"target")»
89	«IF upperMultiplicities.containsKey(relation)»	90	«IF upperMultiplicities.containsKey(relation)»
90	// There are "numberOfExistingReferences" currently existing instances of the reference from the source,	91	// There are "numberOfExistingReferences" currently existing instances of the reference from the source,
91	// the upper bound of the multiplicity should be considered.	92	// the upper bound of the multiplicity should be considered.
92	numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»	93	numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»
93	numberOfExistingReferences != «upperMultiplicities.get(relation)»;	94	numberOfExistingReferences != «upperMultiplicities.get(relation)»;
94	«ENDIF»	95	«ENDIF»
95	«IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»	96	«IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»
96	// There are "numberOfExistingReferences" currently existing instances of the reference to the target,	97	// There are "numberOfExistingReferences" currently existing instances of the reference to the target,
97	// the upper bound of the opposite reference multiplicity should be considered.	98	// the upper bound of the opposite reference multiplicity should be considered.
98	numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»	99	numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»
99	numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»;	100	numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»;
100	«ENDIF»	101	«ENDIF»
101	«IF containments.contains(relation)»	102	«IF containments.contains(relation)»
102	// The reference is containment, then a new reference cannot be create if:	103	// The reference is containment, then a new reference cannot be create if:
103	// 1. Multiple parents	104	// 1. Multiple parents
104	neg «base.containmentIndexer.referMustContaint("_","target")»	105	neg «base.containmentIndexer.referMustContaint("_","target")»
105	// 2. Circle in the containment hierarchy	106	// 2. Circle in the containment hierarchy
106	neg «base.containmentIndexer.referTransitiveMustContains("target","source")»	107	neg «base.containmentIndexer.referTransitiveMustContains("target","source")»
107	«ENDIF»	108	«ENDIF»
108	«IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»	109	«IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»
109	// The eOpposite of the reference is containment, then a referene cannot be created if	110	// The eOpposite of the reference is containment, then a referene cannot be created if
110	// 1. Multiple parents	111	// 1. Multiple parents
111	neg «base.containmentIndexer.referMustContaint("source","_")»	112	neg «base.containmentIndexer.referMustContaint("source","_")»
112	// 2. Circle in the containment hierarchy	113	// 2. Circle in the containment hierarchy
113	neg «base.containmentIndexer.referTransitiveMustContains("source","target")»	114	neg «base.containmentIndexer.referTransitiveMustContains("source","target")»
114	«ENDIF»	115	«ENDIF»
115	} or {	116	«IF mustNotRelations.empty»
116	«relation.referRelation("source","target",Modality.MUST)»	117	// ![] unit propagation relations
117	}	118	«FOR mustNotRelation : mustNotRelations»
118	'''	119	neg find «mustNotRelation»(problem, interpretation, source, target);
		120	«ENDFOR»
		121	«ENDIF»
		122	} or {
		123	«relation.referRelation("source","target",Modality.MUST)»
		124	}
		125	'''
119	}	126	}
120		127
121	def generateDerivedMustRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''	128	def generateDerivedMustRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''
122	/**	129	/**
123	* Matcher for detecting tuples t where []«relation.name»(source,target)	130	* Matcher for detecting tuples t where []«relation.name»(source,target)
@@ -129,6 +136,7 @@ class RelationDeclarationIndexer {
129	«base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MUST,true,false)»	136	«base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MUST,true,false)»
130	}	137	}
131	'''	138	'''
		139
132	def generateDerivedMayRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''	140	def generateDerivedMayRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''
133	/**	141	/**
134	* Matcher for detecting tuples t where []«relation.name»(source,target)	142	* Matcher for detecting tuples t where []«relation.name»(source,target)
@@ -140,4 +148,4 @@ class RelationDeclarationIndexer {
140	«base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MAY,true,false)»	148	«base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MAY,true,false)»
141	}	149	}
142	'''	150	'''
143	} \ No newline at end of file	151	}