7 files changed, 512 insertions, 211 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend
index e511a961..fd4374f5 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend
@@ -11,7 +11,5 @@ import org.eclipse.xtend.lib.annotations.Data
 class CanonisedFormulae {
        CharSequence viatraCode
        Map<Assertion,String> assertion2ConstraintPattern
-        Map<ConstantDefinition,String> constant2ValuePattern
        Map<RelationDefinition,String> relation2ValuePattern
-        Map<FunctionDefinition,String> function2ValuePattern
 }
 \ 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/formulacanonization/FormulaCanoniser.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/FormulaCanoniser.xtend
index 0af0b36a..182f3a3a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/FormulaCanoniser.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/FormulaCanoniser.xtend
@@ -5,17 +5,35 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDefinition
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDefinition
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition
 import java.util.List
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable
 /**
- * Translates a set of assertions and definitions to viatra patterns.
+ * Translates a Terms into format
+ * <P(x1,...,xn)> := Bodies(x1,...,xn)
+ * <Bodies(x1,...,xn)> := <Body(x1,...,xn)> | <Body(x1,...,xn)> or <Bodies(x1,...,xn)>
+ * <Body(x1,...,xn)> := Exists y1,...,ym : <Constraints(x1,...,xn,y1,....,ym)>
+ * <Constraints(x1,...,xn)> := Constraint(x1,...xn) | Constraint(x1,...,xn) and <Constraints(x1,...,xn)>   
 */
 class FormulaCanoniser {
-        def canonise(
+//      def canonise(
-                List<Assertion> assertions,
+//              List<Assertion> assertions,
-                List<RelationDefinition> relations,
+//              List<RelationDefinition> relations)
-                List<ConstantDefinition> constants,
+//      {
-                List<FunctionDefinition> functions)
+//              
-        {
+//      }
-                
+//      
-        }
+//      
+//      def canoniseToConstraintBlock(Term predicate, List<Variable> variables) {
+//              val 
+//      }
+//      
+//      def freeVariables(Term t) {
+//              val subterms = #[t]+t.eAllContents.toList
+//              val variables = subterms.filter(Variable).toSet
+//              val variableReferences = subterms.filter(SymbolicValue).filter[it.symbolicReference instanceof Variable]
+//              val freeVariables = variableReferences.filter[!variables.contains(it.symbolicReference)]
+//              return freeVariables.map
+//      }
 }
 \ 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/PConstraintTransformer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
new file mode 100644
index 00000000..a421d1fd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
@@ -0,0 +1,243 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
+import hu.bme.mit.inf.dslreasoner.viatra2logic.XExpressionExtractor
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import org.eclipse.emf.ecore.EAttribute
+import org.eclipse.emf.ecore.EEnumLiteral
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey
+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint
+import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.VariableMapping
+import java.util.List
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference
+class PConstraintTransformer {
+        val extension RelationDefinitionIndexer relationDefinitionIndexer;
+        val expressionExtractor = new XExpressionExtractor
+        val expressionGenerator = new PExpressionGenerator
+        
+        new(RelationDefinitionIndexer relationDefinitionIndexer) {
+                this.relationDefinitionIndexer = relationDefinitionIndexer
+        }
+        
+        dispatch def transformConstraint(TypeConstraint constraint, Modality modality, List<VariableMapping> variableMapping) {
+                val touple = constraint.variablesTuple
+                if(touple.size == 1) {
+                        val inputKey = constraint.equivalentJudgement.inputKey
+                        if(inputKey instanceof EClassTransitiveInstancesKey) {
+                                return relationDefinitionIndexer.base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,
+                                        constraint.getVariableInTuple(0).canonizeName)
+                        } else if(inputKey instanceof EDataTypeInSlotsKey){
+                                return '''// type constraint is enforced by construction'''
+                        }
+                        
+                } else if(touple.size == 2){
+                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey
+                        if(key instanceof EReference) {
+                                return base.referRelationByName(
+                                        key,
+                                        constraint.getVariableInTuple(0).canonizeName,
+                                        constraint.getVariableInTuple(1).canonizeName,
+                                        modality.toMustMay)
+                        } else if (key instanceof EAttribute) {
+                                return base.referAttributeByName(key,
+                                        constraint.getVariableInTuple(0).canonizeName,
+                                        constraint.getVariableInTuple(1).canonizeName,
+                                        modality.toMustMay)
+                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')
+                } else {
+                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')
+                }
+        }
+        dispatch def transformConstraint(TypeFilterConstraint constraint, Modality modality, List<VariableMapping> variableMapping) {
+                val touple = constraint.variablesTuple
+                if(touple.size == 1) {
+                        val inputKey = constraint.equivalentJudgement.inputKey
+                        if(inputKey instanceof EClassTransitiveInstancesKey) {
+                                return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,
+                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName)
+                        } else if(inputKey instanceof EDataTypeInSlotsKey){
+                                return '''// type constraint is enforced by construction'''
+                        }
+                        
+                } else if(touple.size == 2){
+                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey
+                        if(key instanceof EReference) {
+                                return base.referRelationByName(
+                                        key,
+                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,
+                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,
+                                        modality.toMustMay)
+                        } else if (key instanceof EAttribute) {
+                                return base.referAttributeByName(key,
+                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,
+                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,
+                                        modality.toMustMay)
+                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')
+                } else {
+                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')
+                }
+        }
+        
+        dispatch def transformConstraint(Equality equality, Modality modality, List<VariableMapping> variableMapping) {
+                val a = equality.who
+                val b = equality.withWhom
+                transformEquality(modality.toMustMay, a, b)
+        }
+        
+        private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) {
+                if(modality.isMustOrCurrent) '''find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
+                else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
+        }       
+        
+        dispatch def transformConstraint(Inequality inequality, Modality modality, List<VariableMapping> variableMapping) {
+                val a = inequality.who
+                val b = inequality.withWhom
+                if(modality.isCurrent) {
+                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
+                } else if(modality.isMust) {
+                        return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
+                } else { // modality.isMay
+                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
+                }
+        }
+        
+        dispatch def transformConstraint(NegativePatternCall pcall, Modality modality, List<VariableMapping> variableMapping) {
+                val params = (0..<pcall.actualParametersTuple.size).map[index | 
+                        val variable = pcall.actualParametersTuple.get(index) as PVariable
+                        return variable.canonizeName
+                ]
+                return referPattern(pcall.referredQuery,params,modality.dual,false,false)
+        }
+        
+        dispatch def transformConstraint(PositivePatternCall pcall, Modality modality, List<VariableMapping> variableMapping) {
+                val params = (0..<pcall.variablesTuple.size).map[index | 
+                        val variable = pcall.variablesTuple.get(index) as PVariable
+                        return variable.canonizeName
+                ]
+                return referPattern(pcall.referredQuery,params,modality,true,false)
+        }
+        dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality, List<VariableMapping> variableMapping) {
+                val params = (0..1).map[index | 
+                        val variable = pcall.getVariableInTuple(index) as PVariable
+                        return variable.canonizeName
+                ]
+                return referPattern(pcall.referredQuery,params,modality,true,true)
+        }
+        dispatch def transformConstraint(ExportedParameter e, Modality modality, List<VariableMapping> variableMapping) {
+                return '''// «e.parameterName» is exported'''
+        }
+        dispatch def transformConstraint(ConstantValue c, Modality modality, List<VariableMapping> variableMapping) {
+                val target = c.supplierKey
+                
+                var String targetString;
+                var String additionalDefinition;
+                if(target instanceof EEnumLiteral) {
+                        targetString = '''const_«target.name»_«target.EEnum.name»'''
+                        additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.EEnum.name»");  //LogicProblem.elements(problem,«targetString»);'''
+                } else if(target instanceof Integer) {
+                        targetString = '''const_«target»_Integer'''
+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); IntegerElement.value(«targetString»,«target»);'''
+                } else if(target instanceof Boolean) {
+                        targetString = '''const_«target»_Boolean'''
+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); BooleanElement.value(«targetString»,«target»);'''
+                } else if(target instanceof String) {
+                        targetString = '''const_«target»_String'''
+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); StringElement.value(«targetString»,"«target»");'''
+                } else if(target instanceof Double) {
+                        targetString = '''const_«target»_Real'''
+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); RealElement.value(«targetString»,«target»);'''
+                } else if(target instanceof Float) {
+                        targetString = '''const_«target»_Real'''
+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); RealElement.value(«targetString»,«target»);'''
+                } else {
+                        throw new UnsupportedOperationException('''Unknown constant type: «target.class»''')
+                }
+                
+                val source = c.variablesTuple
+                var String sourceName
+                if(source.size == 1)
+                        sourceName = (source.get(0) as PVariable).canonizeName
+                else throw new UnsupportedOperationException("unknown source")
+                return '''«sourceName» == «targetString»;«additionalDefinition»''';
+        }
+        
+        protected def valueVariable(PVariable v) {
+                "value_"+v.canonizeName
+        }
+        protected def valueSetted(PVariable v) {
+                "setted_"+v.canonizeName
+        }
+        def hasValue(PVariable v, String target, Modality m, List<VariableMapping> variableMapping) {
+                val typeReference = variableMapping.filter[it.sourcePVariable === v].head.targetLogicVariable.range as PrimitiveTypeReference
+                if(m.isMay) {
+                        '''PrimitiveElement.valueSet(«v.canonizeName»,«v.valueSetted»); «hasValueExpression(typeReference,v,v.valueVariable)» check(!«v.valueSetted»||«v.valueVariable»==«target»));'''
+                } else { // Must or current
+                        '''PrimitiveElement.valueSet(«v.canonizeName»,true);«hasValueExpression(typeReference,v,target)»'''
+                }
+        }
+        
+        private def hasValueExpression(List<VariableMapping> variableMapping, PVariable v, String target) {
+                hasValueExpression(
+                        variableMapping.filter[it.sourcePVariable === v].head.targetLogicVariable.range,
+                        v,
+                        target
+                )
+        }
+        private def dispatch hasValueExpression(BoolTypeReference typeReference, PVariable v, String target)    '''BooleanElement.value(«v.canonizeName»,«target»);'''
+        private def dispatch hasValueExpression(IntTypeReference typeReference, PVariable v, String target)             '''IntegerElement.value(«v.canonizeName»,«target»);'''
+        private def dispatch hasValueExpression(RealTypeReference typeReference, PVariable v, String target)    '''RealElement.value(«v.canonizeName»,«target»);'''
+        private def dispatch hasValueExpression(StringTypeReference typeReference, PVariable v, String target)  '''StringElement.value(«v.canonizeName»,«target»);'''
+        private def dispatch hasValueExpression(TypeReference typeReference, PVariable v, String target) {
+                throw new UnsupportedOperationException('''Unsupported primitive type reference: «typeReference.class»''')
+        }
+        
+        dispatch def transformConstraint(ExpressionEvaluation e, Modality modality, List<VariableMapping> variableMapping) {
+                if(e.outputVariable!==null) {
+                        throw new UnsupportedOperationException('''Only check expressions are supported "«e.class.name»"!''')
+                } else {
+                        val expression = expressionExtractor.extractExpression(e.evaluator)
+                        if(modality.isMay) {
+                                return '''
+                                        «FOR variable: e.affectedVariables»
+                                                PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)»
+                                        «ENDFOR»
+                                        check(
+                                                «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»
+                                                ||
+                                                («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable])»)
+                                        );
+                                '''
+                        } else { // Must or Current
+                                return '''
+                                        «FOR variable: e.affectedVariables»
+                                                PrimitiveElement.valueSet(«variable.canonizeName»,true); «hasValueExpression(variableMapping,variable,variable.valueVariable)»
+                                        «ENDFOR»
+                                        check(«expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable])»);
+                                '''
+                        }
+                }
+        }
+        dispatch def transformConstraint(PConstraint c, Modality modality, List<VariableMapping> variableMapping) {
+                throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.name»"!''')
+        }
+}
+\ 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/PExpressionGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PExpressionGenerator.xtend
new file mode 100644
index 00000000..303c87b9
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PExpressionGenerator.xtend
@@ -0,0 +1,109 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
+import java.util.Map
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable
+import org.eclipse.xtext.xbase.XBinaryOperation
+import org.eclipse.xtext.xbase.XExpression
+import org.eclipse.xtext.xbase.XFeatureCall
+import org.eclipse.xtext.xbase.XMemberFeatureCall
+import org.eclipse.xtext.xbase.XNumberLiteral
+import org.eclipse.xtext.xbase.XUnaryOperation
+class PExpressionGenerator {
+        static val N_Base = "org.eclipse.xtext.xbase.lib."
+        
+        static val N_PLUS1 = "operator_plus"
+        static val N_MINUS1 = "operator_minus"
+        
+        static val N_MINUS2 = "operator_minus"
+        static val N_PLUS2 = "operator_plus"
+        static val N_POWER = "operator_power"
+        static val N_MULTIPLY = "operator_multiply"
+        static val N_DIVIDE = "operator_divide"
+        static val N_MODULO = "operator_modulo"
+        static val N_LESSTHAN = "operator_lessThan"
+        static val N_LESSEQUALSTHAN = "operator_lessEqualsThan"
+        static val N_GREATERTHAN = "operator_greaterThan"
+        static val N_GREATEREQUALTHAN = "operator_greaterEqualsThan"
+        static val N_EQUALS = "operator_equals"
+        static val N_NOTEQUALS = "operator_notEquals"
+        static val N_EQUALS3 = "operator_tripleEquals"
+        static val N_NOTEQUALS3 = "operator_tripleNotEquals"
+        
+        protected def isN(String name, String s) {
+                val res = name.startsWith(N_Base) && name.endsWith(s)
+                //println('''[«res»] «name» ?= «N_Base»*«s»''')
+                return res
+        }
+        
+        static val N_POWER2 = "java.lang.Math.pow"
+        
+        def dispatch CharSequence translateExpression(XBinaryOperation e, Map<PVariable,String> valueName) {
+                val left = e.leftOperand.translateExpression(valueName)
+                val right = e.rightOperand.translateExpression(valueName)
+                val feature = e.feature.qualifiedName
+                     if(feature.isN(N_MINUS2)) { return '''(«left»-«right»)'''}
+                else if(feature.isN(N_PLUS2)) { return '''(«left»+«right»)''' }
+                else if(feature.isN(N_POWER)) { return '''(«left»^«right»)'''  }
+                else if(feature.isN(N_MULTIPLY)) { return '''(«left»*«right»)''' }
+                else if(feature.isN(N_DIVIDE)) { return '''(«left»/«right»)''' }
+                else if(feature.isN(N_MODULO)) { return '''(«left»%«right»)''' }
+                else if(feature.isN(N_LESSTHAN)) { return '''(«left»<«right»)''' }
+                else if(feature.isN(N_LESSEQUALSTHAN)) { return '''(«left»<=«right»)''' }
+                else if(feature.isN(N_GREATERTHAN)) { return '''(«left»>«right»)''' }
+                else if(feature.isN(N_GREATEREQUALTHAN)) { return '''(«left»>=«right»)''' }
+                else if(feature.isN(N_EQUALS)) { return '''(«left»==«right»)''' }
+                else if(feature.isN(N_NOTEQUALS)) { return '''(«left»!=«right»)''' }
+                else if(feature.isN(N_EQUALS3)) { return '''(«left»===«right»)''' }
+                else if(feature.isN(N_NOTEQUALS3)) { return '''(«left»!==«right»)''' }
+                else {
+                        println("-> " + e.feature+","+e.class)
+                        println("-> " + e.leftOperand)
+                        println("-> " + e.rightOperand)
+                        println("-> " + e.feature.qualifiedName)
+                        throw new UnsupportedOperationException('''Unsupported binary operator feature: "«e.feature.class.simpleName»" - «e»''')
+                }
+        }
+        
+        def dispatch CharSequence translateExpression(XUnaryOperation e, Map<PVariable,String> valueName) {
+                val operand = e.operand.translateExpression(valueName)
+                val feature = e.feature.qualifiedName
+                if(feature.isN(N_MINUS1)) { return '''(-«operand»)'''}
+                else if(feature.isN(N_PLUS1)) { return '''(+«operand»)'''}
+                else{
+                        println("-> " + e.feature+","+e.class)
+                        println("-> " + e.operand)
+                        println("-> " + e.feature.qualifiedName)
+                        throw new UnsupportedOperationException('''Unsupported unary operator feature: "«e.feature.class.simpleName»" - «e»''')
+                }
+        }
+        
+        def dispatch CharSequence translateExpression(XMemberFeatureCall e, Map<PVariable,String> valueName) {
+                val transformedArguments = e.actualArguments.map[translateExpression(valueName)]
+                val feature = e.feature.qualifiedName
+                if(feature == N_POWER2) {
+                        return '''Math.pow(«transformedArguments.get(0)»,«transformedArguments.get(1)»)'''
+                }else {
+                        println(e.feature+","+e.class)
+                        println(e.actualArguments.join(", "))
+                        println(e.feature.qualifiedName)
+                        throw new UnsupportedOperationException('''Unsupported feature call: "«e.feature.qualifiedName»" - «e»''')
+                }
+        }
+        
+        def dispatch CharSequence translateExpression(XFeatureCall e, Map<PVariable,String> valueName) {
+                val featureName = e.feature.qualifiedName
+                val entryWithName = valueName.entrySet.filter[it.key.name == featureName].head
+                if(entryWithName !== null) {
+                        return entryWithName.value
+                } else {
+                        throw new IllegalArgumentException('''Feature call reference to unavailable variable "«featureName»"''')
+                }
+        }
+        
+        def dispatch CharSequence translateExpression(XNumberLiteral l, Map<PVariable,String> valueName) '''«l.value»'''
+        
+        def dispatch CharSequence translateExpression(XExpression expression, Map<PVariable,String> valueName) {
+                throw new UnsupportedOperationException('''Unsupported expression in check or eval: «expression.class.name», «expression»"''')
+        }
+}
+\ 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/PatternGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
index d4c76bb4..379e334a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
@@ -170,6 +170,7 @@ class PatternGenerator {
                        /////////////////////////
                        // 0.1 Existence
                        /////////////////////////
+                        /** [[exist(element)]]=1 */
                        private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
                                find interpretation(problem,interpretation);
                                LogicProblem.elements(problem,element);
@@ -178,6 +179,7 @@ class PatternGenerator {
                                PartialInterpretation.newElements(interpretation,element);
                        }
                        
+                        /** [[exist(element)]]>=1/2 */
                        private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
                            find mustExist(problem,interpretation,element);
                        } or {
@@ -198,57 +200,143 @@ class PatternGenerator {
                        ////////////////////////
                        // 0.2 Equivalence
                        ////////////////////////
-                        pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) {
+                        pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement)
+                        // For non-primitive type. Boolean types always must equivalent or cannot equivalent
+                        {
                                find mayExist(problem,interpretation,a);
                                find mayExist(problem,interpretation,b);
                                a == b;
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                IntegerElement(a);
+                                IntegerElement(b);
+                                PrimitiveElement.valueSet(a,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                IntegerElement(a);
+                                IntegerElement(b);
+                                PrimitiveElement.valueSet(b,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                RealElement(a);
+                                RealElement(b);
+                                PrimitiveElement.valueSet(a,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                RealElement(a);
+                                RealElement(b);
+                                PrimitiveElement.valueSet(b,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                RealElement(a);
+                                IntegerElement(b);
+                                PrimitiveElement.valueSet(a,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                RealElement(a);
+                                IntegerElement(b);
+                                PrimitiveElement.valueSet(b,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                IntegerElement(a);
+                                RealElement(b);
+                                PrimitiveElement.valueSet(a,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                IntegerElement(a);
+                                RealElement(b);
+                                PrimitiveElement.valueSet(b,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                StringElement(a);
+                                StringElement(b);
+                                PrimitiveElement.valueSet(a,false);
+                        } or {
+                                find mayExist(problem,interpretation,a);
+                                find mayExist(problem,interpretation,b);
+                                StringElement(a);
+                                StringElement(b);
+                                PrimitiveElement.valueSet(b,false);
                        }
+                        
                        pattern mustEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) {
+                        // For non-primitive and Boolean primitive type
                                find mustExist(problem,interpretation,a);
                                find mustExist(problem,interpretation,b);
                                a == b;
+                        } or {
+                                find mustExist(problem,interpretation,a);
+                                find mustExist(problem,interpretation,b);
+                                PrimitiveElement.valueSet(a,true);
+                                PrimitiveElement.valueSet(b,true);
+                                IntegerElement.value(a,value);
+                                IntegerElement.value(b,value);
+                        } or {
+                                find mustExist(problem,interpretation,a);
+                                find mustExist(problem,interpretation,b);
+                                PrimitiveElement.valueSet(a,true);
+                                PrimitiveElement.valueSet(b,true);
+                                RealElement.value(a,value);
+                                RealElement.value(b,value);
+                        } or {
+                                find mustExist(problem,interpretation,a);
+                                find mustExist(problem,interpretation,b);
+                                PrimitiveElement.valueSet(a,true);
+                                PrimitiveElement.valueSet(b,true);
+                                RealElement.value(a,value);
+                                IntegerElement.value(b,value);
+                        } or {
+                                find mustExist(problem,interpretation,a);
+                                find mustExist(problem,interpretation,b);
+                                PrimitiveElement.valueSet(a,true);
+                                PrimitiveElement.valueSet(b,true);
+                                IntegerElement.value(a,value);
+                                RealElement.value(b,value);
+                        } or {
+                                find mustExist(problem,interpretation,a);
+                                find mustExist(problem,interpretation,b);
+                                PrimitiveElement.valueSet(a,true);
+                                PrimitiveElement.valueSet(b,true);
+                                StringElement.value(a,value);
+                                StringElement.value(b,value);
                        }
                        
-                        ////////////////////////
-                        // 0.3 Required Patterns by TypeIndexer
-                        ////////////////////////
-                        «typeIndexer.requiredQueries»
-                        
                        //////////
                        // 1. Problem-Specific Base Indexers
                        //////////
                        // 1.1 Type Indexers
                        //////////
-                        // 1.1.1 primitive Type Indexers
+                        // 1.1.1 Required Patterns by TypeIndexer
                        //////////
-«««                  pattern instanceofBoolean(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                        «typeIndexer.requiredQueries»
-«««                          find interpretation(problem,interpretation);
+                        //////////
-«««                          PartialInterpretation.booleanelements(interpretation,element);
+                        // 1.1.2 primitive Type Indexers
-«««                  }
+                        //////////
-«««                  pattern instanceofInteger(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                        // Currently unused. Refer primitive types as:
-«««                          find interpretation(problem,interpretation);
+                        // > PrimitiveElement(element)
-«««                          PartialInterpretation.integerelements(interpretation,element);
+                        // specific types are referred as:
-«««                  } or {
+                        // > BooleanElement(variableName)
-«««                          find interpretation(problem,interpretation);
+                        // > IntegerElement(variableName)
-«««                          PartialInterpretation.newIntegers(interpetation,element);
+                        // > RealElement(variableName)
-«««                  }
+                        // > StringElement(variableName)
-«««                  pattern instanceofReal(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                        // And their value as
-«««                          find interpretation(problem,interpretation);
+                        // > BooleanElement.value(variableName,value)
-«««                          PartialInterpretation.realelements(interpretation,element);
+                        // > IntegerElement.value(variableName,value)
-«««                  } or {
+                        // > RealElement.value(variableName,value)
-«««                          find interpretation(problem,interpretation);
+                        // > StringElement.value(variableName,value)
-«««                          PartialInterpretation.newReals(interpetation,element);
+                        // Whether a value is set is defined by:
-«««                  }
+                        // > PrimitiveElement.valueSet(variableName,isFilled);
-«««                  pattern instanceofString(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
-«««                          find interpretation(problem,interpretation);
-«««                          PartialInterpretation.stringelements(interpretation,element);
-«««                  } or {
-«««                          find interpretation(problem,interpretation);
-«««                          PartialInterpretation.newStrings(interpetation,element);
-«««                  }
-                        
                        //////////
-                        // 1.1.2 domain-specific Type Indexers
+                        // 1.1.3 domain-specific Type Indexers
                        //////////
                        «typeIndexer.generateInstanceOfQueries(problem,emptySolution,typeAnalysisResult)»
                        
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
index 9723373f..bd6e3e6e 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
@@ -5,35 +5,22 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
 import java.util.Map
-import org.eclipse.emf.ecore.EAttribute
-import org.eclipse.emf.ecore.EEnumLiteral
-import org.eclipse.emf.ecore.EReference
-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey
-import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey
-import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey
-import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint
 class RelationDefinitionIndexer {
-        val PatternGenerator base;
+        public val PatternGenerator base;
+        val PConstraintTransformer constraintTransformer;
        
        new(PatternGenerator base) {
                this.base = base
+                this.constraintTransformer = new PConstraintTransformer(this);
        }
        
-        public def generateRelationDefinitions(
+        def generateRelationDefinitions(
                LogicProblem problem,
                Iterable<RelationDefinition> relations,
                Map<String,PQuery> fqn2PQuery) {
@@ -74,7 +61,7 @@ class RelationDefinitionIndexer {
        private def relationDefinitionName(RelationDefinition relation, Modality modality)
                '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»'''
        
-        private def canonizeName(PVariable v) {
+        def canonizeName(PVariable v) {
                return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»'''
        }
        
@@ -87,7 +74,7 @@ class RelationDefinitionIndexer {
                        «FOR body : p.disjunctBodies.bodies SEPARATOR "or"»{
                                find interpretation(problem,interpretation);
                                «FOR constraint : body.constraints»
-                                        «constraint.transformConstraint(modality)»
+                                        «this.constraintTransformer.transformConstraint(constraint,modality,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»
                                «ENDFOR»
                        }«ENDFOR»
                '''
@@ -104,158 +91,14 @@ class RelationDefinitionIndexer {
                '''
        }
        
-        private def toMustMay(Modality modality) {
+        def toMustMay(Modality modality) {
                if(modality == Modality::MAY) return Modality::MAY
                else return Modality::MUST
        } 
        
-        def public referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) '''
+        def referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) '''
                «IF !positive»neg «ENDIF»find «IF transitive»twoParam_«ENDIF»«modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(«IF !transitive»problem,interpretation,«ENDIF»«variables.join(',')»);
        '''
        
-        private dispatch def transformConstraint(TypeConstraint constraint, Modality modality) {
-                val touple = constraint.variablesTuple
-                if(touple.size == 1) {
-                        val inputKey = constraint.equivalentJudgement.inputKey
-                        if(inputKey instanceof EClassTransitiveInstancesKey) {
-                                return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,
-                                        constraint.getVariableInTuple(0).canonizeName)
-                        } else if(inputKey instanceof EDataTypeInSlotsKey){
-                                return '''// type constraint is enforced by construction'''
-                        }
-                        
-                } else if(touple.size == 2){
-                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey
-                        if(key instanceof EReference) {
-                                return base.referRelationByName(
-                                        key,
-                                        constraint.getVariableInTuple(0).canonizeName,
-                                        constraint.getVariableInTuple(1).canonizeName,
-                                        modality.toMustMay)
-                        } else if (key instanceof EAttribute) {
-                                return base.referAttributeByName(key,
-                                        constraint.getVariableInTuple(0).canonizeName,
-                                        constraint.getVariableInTuple(1).canonizeName,
-                                        modality.toMustMay)
-                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')
-                } else {
-                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')
-                }
-        }
-        private dispatch def transformConstraint(TypeFilterConstraint constraint, Modality modality) {
-                val touple = constraint.variablesTuple
-                if(touple.size == 1) {
-                        val inputKey = constraint.equivalentJudgement.inputKey
-                        if(inputKey instanceof EClassTransitiveInstancesKey) {
-                                return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,
-                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName)
-                        } else if(inputKey instanceof EDataTypeInSlotsKey){
-                                return '''// type constraint is enforced by construction'''
-                        }
-                        
-                } else if(touple.size == 2){
-                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey
-                        if(key instanceof EReference) {
-                                return base.referRelationByName(
-                                        key,
-                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,
-                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,
-                                        modality.toMustMay)
-                        } else if (key instanceof EAttribute) {
-                                return base.referAttributeByName(key,
-                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,
-                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,
-                                        modality.toMustMay)
-                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')
-                } else {
-                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')
-                }
-        }
-        
-        private dispatch def transformConstraint(Equality equality, Modality modality) {
-                val a = equality.who
-                val b = equality.withWhom
-                transformEquality(modality.toMustMay, a, b)
-        }
-        
-        private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) {
-                if(modality.isMustOrCurrent) '''find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
-                else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
-        }       
-        
-        private dispatch def transformConstraint(Inequality inequality, Modality modality) {
-                val a = inequality.who
-                val b = inequality.withWhom
-                if(modality.isCurrent) {
-                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
-                } else if(modality.isMust) {
-                        return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
-                } else { // modality.isMay
-                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
-                }
-        }
-        
-        private dispatch def transformConstraint(NegativePatternCall pcall, Modality modality) {
-                val params = (0..<pcall.actualParametersTuple.size).map[index | 
-                        val variable = pcall.actualParametersTuple.get(index) as PVariable
-                        return variable.canonizeName
-                ]
-                return referPattern(pcall.referredQuery,params,modality.dual,false,false)
-        }
        
-        private dispatch def transformConstraint(PositivePatternCall pcall, Modality modality) {
-                val params = (0..<pcall.variablesTuple.size).map[index | 
-                        val variable = pcall.variablesTuple.get(index) as PVariable
-                        return variable.canonizeName
-                ]
-                return referPattern(pcall.referredQuery,params,modality,true,false)
-        }
-        private dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality) {
-                val params = (0..1).map[index | 
-                        val variable = pcall.getVariableInTuple(index) as PVariable
-                        return variable.canonizeName
-                ]
-                return referPattern(pcall.referredQuery,params,modality,true,true)
-        }
-        private dispatch def transformConstraint(ExportedParameter e, Modality modality) {
-                return '''// «e.parameterName» is exported'''
-        }
-        private dispatch def transformConstraint(ConstantValue c, Modality modality) {
-                val target = c.supplierKey
-                
-                var String targetString;
-                var String additionalDefinition;
-                if(target instanceof EEnumLiteral) {
-                        targetString = '''const_«target.name»_«target.EEnum.name»'''
-                        additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.EEnum.name»");  //LogicProblem.elements(problem,«targetString»);'''
-                } else if(target instanceof Integer) {
-                        targetString = '''const_«target»_Integer'''
-                        additionalDefinition = '''IntegerElement.value(«targetString»,«target»);'''
-                } else if(target instanceof Boolean) {
-                        targetString = '''const_«target»_Boolean'''
-                        additionalDefinition = '''BooleanElement.value(«targetString»,«target»);'''
-                } else if(target instanceof String) {
-                        targetString = '''const_«target»_String'''
-                        additionalDefinition = '''StringElement.value(«targetString»,"«target»");'''
-                } else if(target instanceof Double) {
-                        targetString = '''const_«target»_Number'''
-                        additionalDefinition = '''RealElement.value(«targetString»,"«target»");'''
-                } else if(target instanceof Float) {
-                        targetString = '''const_«target»_Number'''
-                        additionalDefinition = '''RealElement.value(«targetString»,"«target»");'''
-                } else {
-                        throw new UnsupportedOperationException('''Unknown constant type: «target.class»''')
-                }
-                
-                val source = c.variablesTuple
-                var String sourceName
-                if(source.size == 1)
-                        sourceName = (source.get(0) as PVariable).canonizeName
-                else throw new UnsupportedOperationException("unknown source")
-                return '''«sourceName» == «targetString»;«additionalDefinition»''';
-        }
-        
-        private dispatch def transformConstraint(PConstraint c, Modality modality) {
-                throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.name»"!''')
-        }
 }
 \ 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/TypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
index d1d57189..41eb75a8 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
@@ -48,5 +48,7 @@ abstract class TypeIndexer {
        public def dispatch CharSequence referPrimitiveValue(String variableName, String value) {
                '''StringElement.value(«variableName»,"«value»");'''
        }
+        public def CharSequence referPrimitiveFilled(String variableName, boolean isFilled) {
+                '''PrimitiveElement.valueSet(«variableName»,«isFilled»);'''
+        }
 }
 \ No newline at end of file