diff --git a/src/main/java/models/terms/DependencyTerm.java b/src/main/java/models/terms/DependencyTerm.java
index 46d871e..2a1ac1f 100644
--- a/src/main/java/models/terms/DependencyTerm.java
+++ b/src/main/java/models/terms/DependencyTerm.java
@@ -1,9 +1,11 @@
 package models.terms;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
-import java.util.stream.IntStream;
+import java.util.TreeMap;
 
+import exceptions.SyntaxException;
 import lombok.Getter;
 import models.algebra.Symbol;
 
@@ -11,50 +13,62 @@
 public class DependencyTerm extends EvaluatableTerm{
 
 	private EvaluatableTerm dependingTerm;
-	private List<EvaluatableTerm> dependedTerms = new ArrayList<>();
-	private List<EvaluatableTerm> argumentTerms = new ArrayList<>();
+	private TreeMap<EvaluatableTerm, EvaluatableTerm> termPairs;
 	
 	
-	public DependencyTerm(EvaluatableTerm dependingTerm, List<EvaluatableTerm> dependedTerms, List<EvaluatableTerm> argumentTerms) {
+	public DependencyTerm(EvaluatableTerm dependingTerm, List<EvaluatableTerm> terms) {
 		super(
-				new Symbol(":", 1 + dependedTerms.size() + argumentTerms.size()), 
-				-1, 
-				dependingTerm.getSize() + argumentTerms.stream().mapToInt(RDLTerm::getSize).sum() + dependedTerms.stream().mapToInt(RDLTerm::getSize).sum()
+				new Symbol(":", 1 + terms.size()),
+				-1,
+				-1
 		);
-		int maxOrder = argumentTerms.stream().mapToInt(EvaluatableTerm::getOrder).max().orElse(-1);
-		if (dependedTerms.get(0).getOrder() < maxOrder) {
-			this.order = dependingTerm.getOrder() + (maxOrder - dependedTerms.get(0).getOrder());
-		} else if (dependedTerms.get(0).getOrder() == maxOrder) {
-			this.order = dependingTerm.getOrder();
-		} else {
-			this.order = dependingTerm.getOrder() - 1;
+		if (terms.size() % 2 != 0) {
+			throw new SyntaxException("Args size must be odd.");
 		}
-		
-		for(int i = 0; i < dependedTerms.size(); i++) {
-			if (dependedTerms.get(0).getOrder() != dependedTerms.get(i).getOrder()) {
-				throw new RuntimeException("dependedTerms order not equals");
+		this.size = dependingTerm.getSize();
+		boolean argOrderType = terms.get(0).getOrder() <= terms.get(1).getOrder();
+		if (argOrderType) {
+			this.order = terms.get(1).getOrder();
+			if (dependingTerm.getOrder() > getOrder() + 1) {
+				throw new SyntaxException("order invalid");
+			}
+		} else {
+			this.order = terms.get(0).getOrder() - 1;
+			if (dependingTerm.getOrder() > getOrder()) {
+				throw new SyntaxException("order invalid");
 			}
 		}
-		
-		if (dependedTerms.size() != argumentTerms.size()) {
-			throw new RuntimeException("Size not equals");
-		}
 		this.dependingTerm = dependingTerm;
-		this.dependedTerms = new ArrayList<>(dependedTerms);
-		this.argumentTerms = new ArrayList<>(argumentTerms);
+		this.termPairs = new TreeMap<>();
 		addChild(dependingTerm);
-		for (int i = 0; i < dependedTerms.size(); i++) {
-			addChild(dependedTerms.get(i));
-			addChild(argumentTerms.get(i));
+		for (int i = 0; i < terms.size() / 2; i++) {
+			EvaluatableTerm dependedTerm = terms.get(2 * i);
+			EvaluatableTerm argTerm = terms.get(2 * i + 1);
+			termPairs.put(dependedTerm, argTerm);
+			this.size += dependedTerm.getSize();
+			this.size += argTerm.getSize();
+			addChild(dependedTerm);
+			addChild(argTerm);
+			if (argOrderType) {
+				if (argTerm.getOrder() != getOrder()) {
+					throw new SyntaxException("order not same");
+				}
+				if (dependedTerm.getOrder() > getOrder()) {
+					throw new SyntaxException("order invalid");
+				}
+			} else {
+				if (dependedTerm.getOrder() - 1 != getOrder()) {
+					throw new SyntaxException("order not same");
+				}
+				if (argTerm.getOrder() > getOrder()) {
+					throw new SyntaxException("order invalid");
+				}
+			}
 		}
 	}
 	
 	public DependencyTerm(EvaluatableTerm dependingTerm, EvaluatableTerm ...terms) {
-		this(
-				dependingTerm, 
-				IntStream.range(0, terms.length).filter(i -> i % 2 == 0).mapToObj(i -> terms[i]).toList(), 
-				IntStream.range(0, terms.length).filter(i -> i % 2 == 1).mapToObj(i -> terms[i]).toList()
-			);
+		this(dependingTerm, Arrays.asList(terms));
 	}
 	
 	@Override
@@ -71,50 +85,10 @@
 	
 	@Override
 	public void selfLinearRightNormalize() {
-//		if(dependingTerm instanceof ResourceVariable || dependingTerm instanceof SetEvaluatableTerm) {
-//			argumentTerm.selfLinearRightNormalize();
-//			return;
-//		}
-//		DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm;
-//		if(! dependencyTerm.isLinearRightNormalized()) {
-//			dependencyTerm.selfLinearRightNormalize();
-//		}
-//		if(! isLinearRightNormalized()) {
-//			EvaluatableTerm childArgumentTerm = dependencyTerm.getArgumentTerm();
-//			DependencyTerm nextDependencyTerm = new DependencyTerm(childArgumentTerm, dependedVariable, argumentTerm);
-//			this.dependingTerm = dependencyTerm.getDependingTerm();
-//			this.dependedVariable = dependencyTerm.getDependedVariable();
-//			this.argumentTerm = nextDependencyTerm;
-//			this.setChild(2, nextDependencyTerm);
-//			this.setChild(0, dependencyTerm.getDependingTerm());
-//			this.setChild(1, dependencyTerm.getDependedVariable());
-//		}
-//		argumentTerm.selfLinearRightNormalize();
 		
 	}
 	
 	private boolean isLinearRightNormaled(int depth) {
-//		if(dependingTerm instanceof ResourceVariable || dependingTerm instanceof SetEvaluatableTerm) {
-//			return dependingTerm.getOrder() == dependedVariable.getOrder();
-//		}
-//		DependencyTerm dependencyTerm = (DependencyTerm) dependingTerm;
-//		if(
-//				dependencyTerm.isLinearRightNormaled(depth + 1) && 
-//				dependencyTerm.getDependedVariable().getOrder() - 1 == dependedVariable.getOrder() && 
-//				dependencyTerm.getOrder() == dependedVariable.getOrder() &&
-//				argumentTerm.getOrder() <= dependencyTerm.getOrder() &&
-//				depth == 0
-//		) {
-//			return true;
-//		}
-//		if(
-//				dependencyTerm.isLinearRightNormaled(depth + 1) && 
-//				dependencyTerm.getDependedVariable().getOrder() - 1 == dependedVariable.getOrder() && 
-//				dependencyTerm.getOrder() == dependedVariable.getOrder() &&
-//				argumentTerm.getOrder() < dependencyTerm.getOrder()
-//		) {
-//			return true;
-//		}
 		
 		return false;
 	}
@@ -126,10 +100,11 @@
 		sb.append('[');
 		sb.append(getDependingTerm().toString());
 		sb.append(" : ");
-		for (int i = 0; i < dependedTerms.size(); i++) {
-			sb.append(dependedTerms.get(i).toString());
+		for (EvaluatableTerm dependedTerm: termPairs.keySet()) {
+			EvaluatableTerm argTerm = termPairs.get(dependedTerm);
+			sb.append(dependedTerm.toString());
 			sb.append(" -> ");
-			sb.append(argumentTerms.get(i).toString());
+			sb.append(argTerm.toString());
 			sb.append(", ");
 		}
 		sb.deleteCharAt(sb.length() - 1);
@@ -144,13 +119,15 @@
 		sb.append('[');
 		sb.append(getDependingTerm().toStringWithOrder());
 		sb.append(" : ");
-		for (int i = 0; i < dependedTerms.size(); i++) {
-			sb.append(dependedTerms.get(i).toStringWithOrder());
+		for (EvaluatableTerm dependedTerm: termPairs.keySet()) {
+			EvaluatableTerm argTerm = termPairs.get(dependedTerm);
+			sb.append(dependedTerm.toStringWithOrder());
 			sb.append(" -> ");
-			sb.append(argumentTerms.get(i).toStringWithOrder());
+			sb.append(argTerm.toStringWithOrder());
 			sb.append(", ");
 		}
 		sb.deleteCharAt(sb.length() - 1);
+		sb.deleteCharAt(sb.length() - 1);
 		sb.append(']');
 		sb.append('(');
 		sb.append(order);
@@ -166,8 +143,7 @@
 		DependencyTerm term = (DependencyTerm) another;
 		
 		return dependingTerm.equals(term.getDependingTerm()) && 
-				dependedTerms.stream().sorted().toList().equals(term.getDependedTerms().stream().sorted().toList()) &&
-				argumentTerms.stream().sorted().toList().equals(term.getArgumentTerms().stream().sorted().toList());
+				termPairs.equals(term.getTermPairs());
 	}
 
 	@Override
@@ -177,10 +153,14 @@
 
 	@Override
 	public Object clone() {
+		List<EvaluatableTerm> termPairs = new ArrayList<>();
+		for (EvaluatableTerm dependedTerm : this.termPairs.keySet()) {
+			termPairs.add(dependedTerm);
+			termPairs.add(this.termPairs.get(dependedTerm));
+		}
 		return new DependencyTerm(
 				(EvaluatableTerm) dependingTerm.clone(),
-				new ArrayList<>(dependedTerms),
-				new ArrayList<>(argumentTerms)
+				termPairs
 		);
 	}