public boolean isConcurrent(String pathExpression1, String pathExpression2, String operator1, String operator2, String type1, String type2){
		ExpressionAction exprAction = new ExpressionAction();
		//Auslesen des VariablenName
		String varName1 = exprAction.getVariableName(pathExpression1);
		String varName2 = exprAction.getVariableName(pathExpression2);
		
		/*
		 * 1.1 Variable.MsgPart
		 * 1.1.1.1 Variable.MsgPart/Locationpath
		 * 1 Variable
		 * 1.2.1 Variable/Locationpath
		 */
		
		//1 Falls die Variablen gleich sind
		if (varName1.equals(varName2)){
			LocationpathAnalyzer locAnalyzer = new LocationpathAnalyzer();
			
			//1.1 Falls beide Pfadausdrcke einen Part besitzen
			if (exprAction.hasPartName(pathExpression1) && exprAction.hasPartName(pathExpression2)){
				//Auslesen des PartNamens
				String partName1 = exprAction.getPartName(pathExpression1);
				String partName2 = exprAction.getPartName(pathExpression2);
				
				//1.1.1 Falls die Parts gleich sind
				if (partName1.equals(partName2)){
					//1.1.1.1 Falls beide Pfadausdrcke je einen Lokalisierungspfad besitzen
					if (exprAction.hasLocationpath(pathExpression1) && exprAction.hasLocationpath(pathExpression2)){
						//Auslesen des Lokalisierungspfades und Bereinigen desselben
						String locationpath1 = exprAction.getLocationpath(pathExpression1);
						locationpath1 = exprAction.removeDescendantNode(locationpath1);
						String locationpath2 = exprAction.getLocationpath(pathExpression2);
						locationpath2 = exprAction.removeDescendantNode(locationpath2);
						
						//1.1.1.1.1 Falls die Lokalisierungspfade keine Attribute und keine relationalen Operatoren beinhalten
						if (!exprAction.containsAttribute(locationpath1) && !exprAction.containsAttribute(locationpath2) && !exprAction.containsRelOp(locationpath1) && !exprAction.containsRelOp(locationpath2)){
							
							//1.1.1.1.1.1 Falls die Typen der beiden Bedingungen identisch sind
							if (type1.equals(type2)){
								XMLParser xmlParser = new XMLParser();
								Element bpelRoot = xmlParser.parseXMLFile(bpelFileName);
								
								//Falls die Variable einen part besitzt, besitzt die Variable automatisch ein messageType Attribut
								BPELReader bpelReader = new BPELReader();
								String msgName = bpelReader.getVariableAttribute(bpelRoot, varName1, "messageType");
//@WSDL-BEGIN								
								//aus bpelFile Name des entsprechenden wsdlFiles holen 
									
								//mit WSDL4J auf message und part in wsdlFile zugreifen mit msgName und partName1
								//xsd aus type-Attribut (immer complexType, da locationpath existiert) bzw. element-Attribut holen
								//Da der MuSatSolver noch nicht vollsndig vorliegt kann das XML-Schema nicht zum
								//Schnitttest herangezogen werden. Daher wird an dieser Stelle nur eine Zeichenkette bergeben. 
								String xsdFileName = msgName.concat(partName1).concat(".xsd");
//@WSDL-END							
								boolean existsIntersect = locAnalyzer.existsIntersection(locationpath1, locationpath2, xsdFileName);
									
								//Falls sich die Lokalisierungspfade schneiden
								if (existsIntersect){
									return mutuallyExclusive(operator1, operator2, type1, type2);
										
								//Falls die Lokalisierungspfade verschieden sind (sie sich nicht schneiden)
								} else {
									return true;
								}
							//1.1.1.1.1.2 Falls die Typen der beiden Bedingungen verschieden sind
							} else {
								System.err.println("Die Datentypen in den Bedingungen sind von unterschiedlichem Typ. Die Forderung, dass nur dieselben Typen verglichen werden koennen, wird verletzt!");
								System.exit(0);
								return false;
							}
						//1.1.1.1.2 Falls die Lokalisierungspfade Attribute oder relationale Operatoren enthalten
						} else if ((exprAction.containsAttribute(locationpath1) && exprAction.containsAttribute(locationpath2)) ||  exprAction.containsRelOp(locationpath1) && exprAction.containsRelOp(locationpath2)){
							
							//1.1.1.1.2.1 Falls die Typen der beiden Bedingungen identisch sind
							if (type1.equals(type2)){
								boolean expressionsEqual = locAnalyzer.expressionsEqual(locationpath1, locationpath2);
								
								//1.1.1.1.2.1.1 Falls die Lokalisierungspfade quivalent sind
								if (expressionsEqual){
									return mutuallyExclusive(operator1, operator2, type1, type2);
									
								//1.1.1.1.2.1.2 Falls die Lokalisierungspfade verschieden sind
								} else {
									return true;
								}
							//1.1.1.1.2.2 Falls die Typen der beiden Bedingungen verschieden sind
							} else {
								System.err.println("Die Datentypen in den Bedingungen sind von unterschiedlichem Typ. Die Forderung, dass nur dieselben Typen verglichen werden koennen, wird verletzt!");
								System.exit(0);
								return false;
							}						
						//1.1.1.1.3 Falls nur ein Lokalsierungspfad Attribute enthlt 	
						} else {
							System.err.println("Lokalisierungspfade "+locationpath1+ " und "+locationpath2+" koennen nicht analysiert werden. Entweder enthalten beide Lokalisierungspfade Attribute oder keiner von beiden!");
							System.exit(0);
							return false;
						}
					//1.1.1.2 Falls beide Pfadausdrcke keinen Lokalisierungspfad besitzen
					} else if (!exprAction.hasLocationpath(pathExpression1) && !exprAction.hasLocationpath(pathExpression2)){
					
						//1.1.1.2.1 Falls die Typen der beiden Bedingungen identisch sind
						if (type1.equals(type2)){
							return mutuallyExclusive(operator1, operator2, type1, type2);
							
						//1.1.1.2.2 Falls die Typen der beiden Bedingungen verschieden sind
						} else {
							System.err.println("Die Datentypen in den Bedingungen sind von unterschiedlichem Typ. Die Forderung, dass nur dieselben Typen verglichen werden koennen, wird verletzt!");
							System.exit(0);
							return false;
						}					
					//1.1.1.3 Falls nur einer der Pfadausdrcke einen Lokalisierungspfad besitzt 
					} else {
						System.err.println("Pfadausdruecke "+ pathExpression1+ " und " +pathExpression2+" nicht zulaessig, entweder besitzen beide Pfadausdrcke einen Lokalisierungspfad oder keiner von beiden!");
						System.exit(0);
						return false;
					}
				//1.1.2 Falls die Parts verschieden sind	
				} else {
					return true;
				}
			//1.2 Falls beide Pfadausdrcke keinen Part besitzen
			} else if (!exprAction.hasPartName(pathExpression1) && !exprAction.hasPartName(pathExpression2)){
				//1.2.1 Falls beide Pfadausdrcke einen Lokalisierungspfad besitzen
				if (exprAction.hasLocationpath(pathExpression1) && exprAction.hasLocationpath(pathExpression2)){
					//Auslesen des Lokalisierungspfades und Bereinigen desselben
					String locationpath1 = exprAction.getLocationpath(pathExpression1);
					locationpath1 = exprAction.removeDescendantNode(locationpath1);
					String locationpath2 = exprAction.getLocationpath(pathExpression2);
					locationpath2 = exprAction.removeDescendantNode(locationpath2);
					
					//1.2.1.1 Falls die Lokalisierungspfade keine Attribute enthalten und keine relationalen Operatoren beinhalten
					if (!exprAction.containsAttribute(locationpath1) && !exprAction.containsAttribute(locationpath2) && !exprAction.containsRelOp(locationpath1) && !exprAction.containsRelOp(locationpath2)){						
						
						//1.2.1.1.1 Falls die Typen der beiden Bedingungen identisch sind
						if (type1.equals(type2)){
							XMLParser xmlParser = new XMLParser();
							Element bpelRoot = xmlParser.parseXMLFile(bpelFileName);
							
							//aus bpelFile Name des entsprechenden wsdlFiles holen
							BPELReader bpelReader = new BPELReader();
							String xsdFileName = null;
//@WSDL-BEGIN						
							//Falls die Variable ein element-Attribut besitzt
							if (bpelReader.hasVariableAttribute(bpelRoot, varName1, "element")){
								String elementName = bpelReader.getVariableAttribute(bpelRoot, varName1, "element");
								
								//mit WSDL4J xsd ber element-attribut holen
								xsdFileName = elementName+".xsd";
						
							//Falls die Variable ein type-Attribut besitzt (muss sie dann)
							} else {
								String typeName = bpelReader.getVariableAttribute(bpelRoot, varName1, "type");
								
								//mit WSDL4J xsd ber type-Attribut (immer complexType, da locationpath existiert) holen
								xsdFileName = typeName+".xsd";
							}
//@WSDL-END						
							//Da der MuSatSolver noch nicht vollsndig vorliegt kann das XML-Schema nicht zum
							//Schnitttest herangezogen werden. Daher wird an dieser Stelle nur eine Zeichenkette bergeben.
							boolean existsIntersect = locAnalyzer.existsIntersection(locationpath1, locationpath2, xsdFileName);
							
							//Falls sich die Lokalisierungspfade schneiden
							if (existsIntersect){
								return mutuallyExclusive(operator1, operator2, type1, type2);
								
							//Falls die Lokalisierungspfade verschieden sind
							} else {
								return true;
							}
							//1.2.1.1.2 Falls die Typen der beiden Bedingungen verschieden sind
						} else {
							System.err.println("Die Datentypen in den Bedingungen sind von unterschiedlichem Typ. Die Forderung, dass nur dieselben Typen verglichen werden koennen, wird verletzt!");
							System.exit(0);
							return false;
						}
					//1.2.1.2 Falls die Lokalisierungspfade Attribute oder relationale Operatoren enthalten
					} else if ((exprAction.containsAttribute(locationpath1) && exprAction.containsAttribute(locationpath2)) ||  exprAction.containsRelOp(locationpath1) && exprAction.containsRelOp(locationpath2)){
						
						//1.2.1.2.1 Falls die Typen der beiden Bedingungen identisch sind
						if (type1.equals(type2)){
							boolean expressionsEqual = locAnalyzer.expressionsEqual(locationpath1, locationpath2);
							
							//1.2.1.2.1.1 Falls die Lokalisierungspfade quivalent sind
							if (expressionsEqual){
								return mutuallyExclusive(operator1, operator2, type1, type2);

							//1.2.1.2.1.2 Falls die Lokalisierungspfade verschieden sind
							} else {
								return true;
							}
						//1.2.1.2.2 Falls die Typen der beiden Bedingungen verschieden sind
						} else {
							System.err.println("Die Datentypen in den Bedingungen sind von unterschiedlichem Typ. Die Forderung, dass nur dieselben Typen verglichen werden koennen, wird verletzt!");
							System.exit(0);
							return false;
						}
					//1.2.1.2 Falls nur ein Lokalsierungspfad Attribute enthlt
					} else {
						System.err.println("Lokalisierungspfade "+locationpath1+ " und "+locationpath2+" koennen nicht analysiert werden. Entweder enthalten beide Lokalisierungspfade Attribute oder keiner von beiden!");
						System.exit(0);
						return false;
					}
				//1.2.2 Falls keiner der Pfadausdrcke einen Lokalisierungspfad besitzt
				} else if (!exprAction.hasLocationpath(pathExpression1) && !exprAction.hasLocationpath(pathExpression2)){
					
					//1.2.2.1 Falls die Typen der beiden Bedingungen identisch sind
					if (type1.equals(type2)){
						return mutuallyExclusive(operator1, operator2, type1, type2);
						
					//1.2.2.2 Falls die Typen der beiden Bedingungen verschieden sind
					} else {
						System.err.println("Die Datentypen in den Bedingungen sind von unterschiedlichem Typ. Die Forderung, dass nur dieselben Typen verglichen werden koennen, wird verletzt!");
						System.exit(0);
						return false;
					}
				//1.2.3 Falls nur einer der Pfadausdrcke einen Lokalisierungspfad besitzt
				} else {
					System.err.println("Pfadausdruecke "+ pathExpression1+ " und " +pathExpression2+" nicht zulaessig, entweder besitzen beide Pfadausdruecke einen Lokalisierungspfad oder keiner von beiden!");
					System.exit(0);
					return false;
				}
			//1.3 Falls nur ein Pfadausdruck einen Part besitzt
			} else {
				System.err.println("Pfadausdruecke "+ pathExpression1+ " und " +pathExpression2+" nicht zulaessig, entweder besitzen beide Pfadausdruecke einen Part oder keiner von beiden!");
				System.exit(0);
				return false;
			}
		//1 Falls die Variablen verschieden sind
		} else {
			return true;
		}
	}