diff --git a/spec/jastadd/Backend.jadd b/spec/jastadd/Backend.jadd
index 4e09448ebd8fb60d8eb31714a11b5db8fe645af2..835e9ec593d0fed28fb41ff2dc08d34d362b966f 100644
--- a/spec/jastadd/Backend.jadd
+++ b/spec/jastadd/Backend.jadd
@@ -187,7 +187,7 @@ aspect BackendDirectedAPI {
 		generateGetMany(sb);
 
 		// Add
-		sb.append(ind(1) + "public void " + toTypeDecl() + ".addTo");
+		sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
 		sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
 		sb.append(ind(2) + "assertNotNull(o);\n");
 		sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -199,7 +199,7 @@ aspect BackendDirectedAPI {
 		sb.append(ind(1) + "}\n");
 
 		// Remove
-		sb.append(ind(1) + "public void " + toTypeDecl() + ".removeFrom");
+		sb.append(ind(1) + "public void " + toTypeDecl() + ".remove");
 		sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
 		sb.append(ind(2) + "assertNotNull(o);\n");
 		sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -211,7 +211,7 @@ aspect BackendDirectedAPI {
 
 	public void RelationComponent.generateGetOne(StringBuilder sb) {
 		sb.append(ind(1) + "public " + ofTypeDecl() + " " + toTypeDecl());
-		sb.append("." + name() + "() {\n");
+		sb.append(".get" + nameCapitalized() + "() {\n");
 		sb.append(ind(2) + "return get" + getImplAttributeName() + "();\n");
 		sb.append(ind(1) + "}\n");
 	}
@@ -220,7 +220,7 @@ aspect BackendDirectedAPI {
 		// has
 		sb.append(ind(1) + "public boolean " + toTypeDecl());
 		sb.append(".has" + nameCapitalized() + "() {\n");
-		sb.append(ind(2) + "return " + name() + "() != null;\n");
+		sb.append(ind(2) + "return get" + nameCapitalized() + "() != null;\n");
 		sb.append(ind(1) + "}\n");
 
 		// clear
@@ -231,8 +231,15 @@ aspect BackendDirectedAPI {
 	}
 
 	public void RelationComponent.generateGetMany(StringBuilder sb) {
+		// getXs
 		sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
-		sb.append("." + name() + "() {\n");
+		sb.append(".get" + nameCapitalized() + "s() {\n");
+		sb.append(ind(2) + "return get" + nameCapitalized() + "List();\n");
+		sb.append(ind(1) + "}\n");
+
+		// getXList
+		sb.append(ind(1) + "public java.util.List<" + ofTypeDecl() + "> " + toTypeDecl());
+		sb.append(".get" + nameCapitalized() + "List() {\n");
 		sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> l = get"
 			+ getImplAttributeName() + "();\n");
 		sb.append(ind(2) + "return l != null ? Collections.unmodifiableList(l) : Collections.emptyList();\n");
@@ -317,7 +324,7 @@ aspect BackendBidirectionalAPI {
 		generateGetMany(sb);
 
 		// Add
-		sb.append(ind(1) + "public void " + toTypeDecl() + ".addTo");
+		sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
 		sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
 		sb.append(ind(2) + "assertNotNull(o);\n");
 		sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -336,7 +343,7 @@ aspect BackendBidirectionalAPI {
 		sb.append(ind(1) + "}\n");
 
 		// Remove
-		sb.append(ind(1) + "public void " + toTypeDecl() + ".removeFrom");
+		sb.append(ind(1) + "public void " + toTypeDecl() + ".remove");
 		sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
 		sb.append(ind(2) + "assertNotNull(o);\n");
 		sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -356,7 +363,7 @@ aspect BackendBidirectionalAPI {
 		generateGetMany(sb);
 
 		// Add
-		sb.append(ind(1) + "public void " + toTypeDecl() + ".addTo");
+		sb.append(ind(1) + "public void " + toTypeDecl() + ".add");
 		sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
 		sb.append(ind(2) + "assertNotNull(o);\n");
 		sb.append(ind(2) + "if (o != null && o.get" + otherSide().getImplAttributeName() + "() != null) {\n");
@@ -376,7 +383,7 @@ aspect BackendBidirectionalAPI {
 		sb.append(ind(1) + "}\n");
 
 		// Remove
-		sb.append(ind(1) + "public void " + toTypeDecl() + ".removeFrom");
+		sb.append(ind(1) + "public void " + toTypeDecl() + ".remove");
 		sb.append(nameCapitalized() + "(" + ofTypeDecl() + " o) {\n");
 		sb.append(ind(2) + "assertNotNull(o);\n");
 		sb.append(ind(2) + ASTNode.listClass + "<" + ofTypeDecl() + "> list = get" + getImplAttributeName() + "();\n");
@@ -470,7 +477,7 @@ aspect LowerBoundCheck {
 	}
 
 	public void OneRelationComponent.generateLowerBoundCheck(StringBuilder sb) {
-		sb.append(ind(2) + "if (" + name() + "() == null) {\n");
+		sb.append(ind(2) + "if (get" + nameCapitalized() + "() == null) {\n");
 		sb.append(ind(3) + "list.add(new Pair<>(this, \"" + name() + "\"));\n");
 		sb.append(ind(2) + "}\n");
 	}
@@ -542,4 +549,4 @@ aspect Utils {
 		}
 		return s;
 	}
-}
\ No newline at end of file
+}
diff --git a/tests/valid/All.java b/tests/valid/All.java
index 80bddeaee6b683515fa37ed219273be48ca178a1..404f3fc3a4bc10bdf21fd1bfe12311bdbc2d9a6b 100644
--- a/tests/valid/All.java
+++ b/tests/valid/All.java
@@ -34,20 +34,20 @@ public class All extends AbstractTests {
 	}
 
 	/**
-	 * rel A.di1 -> B;
+	 * rel A.Di1 -> B;
 	 */
 	private void testDi1() {
 		setup();
 		a1.setDi1(b2);
 		a2.setDi1(b1);
 
-		assertSame(a1.di1(), b2);
-		assertSame(a2.di1(), b1);
+		assertSame(a1.getDi1(), b2);
+		assertSame(a2.getDi1(), b1);
 
 		a2.setDi1(b2);
 
-		assertSame(a1.di1(), b2);
-		assertSame(a2.di1(), b2);
+		assertSame(a1.getDi1(), b2);
+		assertSame(a2.getDi1(), b2);
 
 		try {
 			a3.setDi1(null);
@@ -59,25 +59,25 @@ public class All extends AbstractTests {
 
 
 	/**
-	 * rel A.di2? -> B;
+	 * rel A.Di2? -> B;
 	 */
 	private void testDi2() {
 		setup();
 		a1.setDi2(b2);
 		a2.setDi2(b1);
 
-		assertSame(a1.di2(), b2);
-		assertSame(a2.di2(), b1);
+		assertSame(a1.getDi2(), b2);
+		assertSame(a2.getDi2(), b1);
 
 		a2.setDi2(b2);
 
-		assertSame(a1.di2(), b2);
-		assertSame(a2.di2(), b2);
+		assertSame(a1.getDi2(), b2);
+		assertSame(a2.getDi2(), b2);
 
 		a2.clearDi2();
 
-		assertSame(a1.di2(), b2);
-		assertNull(a2.di2());
+		assertSame(a1.getDi2(), b2);
+		assertNull(a2.getDi2());
 
 		assertTrue(a1.hasDi2());
 		assertFalse(a2.hasDi2());
@@ -86,38 +86,47 @@ public class All extends AbstractTests {
 
 
 	/**
-	 * rel A.di3* -> B;
+	 * rel A.Di3* -> B;
 	 */
 	private void testDi3() {
 		setup();
-		a1.addToDi3(b1);
-		a1.addToDi3(b2);
-		a1.addToDi3(b3);
-		a2.addToDi3(b2);
+		a1.addDi3(b1);
+		a1.addDi3(b2);
+		a1.addDi3(b3);
+		a2.addDi3(b2);
 		
-		assertEquals(a1.di3(), Arrays.asList(b1, b2, b3));
-		assertEquals(a2.di3(), Arrays.asList(b2));
-		assertEquals(a3.di3(), Arrays.asList());
-
-		a1.addToDi3(b1);
-		a2.addToDi3(b1);
-		a2.addToDi3(b2);
-
-		assertEquals(a1.di3(), Arrays.asList(b1, b2, b3, b1));
-		assertEquals(a2.di3(), Arrays.asList(b2, b1, b2));
-		assertEquals(a3.di3(), Arrays.asList());
-
-		a1.removeFromDi3(b1);
-		a2.removeFromDi3(b2);
-
-		assertEquals(a1.di3(), Arrays.asList(b2, b3, b1));
-		assertEquals(a2.di3(), Arrays.asList(b1, b2));
-		assertEquals(a3.di3(), Arrays.asList());
+		assertEquals(a1.getDi3s(), Arrays.asList(b1, b2, b3));
+		assertEquals(a1.getDi3List(), Arrays.asList(b1, b2, b3));
+		assertEquals(a2.getDi3s(), Arrays.asList(b2));
+		assertEquals(a2.getDi3List(), Arrays.asList(b2));
+		assertEquals(a3.getDi3s(), Arrays.asList());
+		assertEquals(a3.getDi3List(), Arrays.asList());
+
+		a1.addDi3(b1);
+		a2.addDi3(b1);
+		a2.addDi3(b2);
+
+		assertEquals(a1.getDi3s(), Arrays.asList(b1, b2, b3, b1));
+		assertEquals(a1.getDi3List(), Arrays.asList(b1, b2, b3, b1));
+		assertEquals(a2.getDi3s(), Arrays.asList(b2, b1, b2));
+		assertEquals(a2.getDi3List(), Arrays.asList(b2, b1, b2));
+		assertEquals(a3.getDi3s(), Arrays.asList());
+		assertEquals(a3.getDi3List(), Arrays.asList());
+
+		a1.removeDi3(b1);
+		a2.removeDi3(b2);
+
+		assertEquals(a1.getDi3s(), Arrays.asList(b2, b3, b1));
+		assertEquals(a1.getDi3List(), Arrays.asList(b2, b3, b1));
+		assertEquals(a2.getDi3s(), Arrays.asList(b1, b2));
+		assertEquals(a2.getDi3List(), Arrays.asList(b1, b2));
+		assertEquals(a3.getDi3s(), Arrays.asList());
+		assertEquals(a3.getDi3List(), Arrays.asList());
 	}
 
 
 	/**
-	 * rel A.bi1 <-> B.bi1;
+	 * rel A.Bi1 <-> B.Bi1;
 	 */
 	private void testBi1() {
 		testBi11();
@@ -132,10 +141,10 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi1(b1);
 
-		assertNull(a1.bi1());
-		assertSame(a2.bi1(), b1);
-		assertSame(b1.bi1(), a2);
-		assertNull(b2.bi1());
+		assertNull(a1.getBi1());
+		assertSame(a2.getBi1(), b1);
+		assertSame(b1.getBi1(), a2);
+		assertNull(b2.getBi1());
 	}
 	private void testBi12() {
 		// Init
@@ -145,16 +154,16 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi1(b2);
 
-		assertNull(a1.bi1());
-		assertSame(a2.bi1(), b2);
-		assertNull(b1.bi1());
-		assertSame(b2.bi1(), a2);
+		assertNull(a1.getBi1());
+		assertSame(a2.getBi1(), b2);
+		assertNull(b1.getBi1());
+		assertSame(b2.getBi1(), a2);
 	}
 
 
 
 	/**
-	 * rel A.bi2 <-> B.bi2?;
+	 * rel A.Bi2 <-> B.Bi2?;
 	 */
 	private void testBi2() {
 		testBi21();
@@ -169,10 +178,10 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi2(b1);
 
-		assertNull(a1.bi2());
-		assertSame(a2.bi2(), b1);
-		assertSame(b1.bi2(), a2);
-		assertNull(b2.bi2());
+		assertNull(a1.getBi2());
+		assertSame(a2.getBi2(), b1);
+		assertSame(b1.getBi2(), a2);
+		assertNull(b2.getBi2());
 	}
 	private void testBi22() {
 		// Init
@@ -182,53 +191,65 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi2(b2);
 
-		assertNull(a1.bi2());
-		assertSame(a2.bi2(), b2);
-		assertNull(b1.bi2());
-		assertSame(b2.bi2(), a2);
+		assertNull(a1.getBi2());
+		assertSame(a2.getBi2(), b2);
+		assertNull(b1.getBi2());
+		assertSame(b2.getBi2(), a2);
 	}
 
 
 
 	/**
-	 * rel A.bi3 <-> B.bi3*;
+	 * rel A.Bi3 <-> B.Bi3*;
 	 */
 	private void testBi3() {
 		setup();
 		a2.setBi3(b2);
 
-		assertNull(a1.bi3());
-		assertSame(a2.bi3(), b2);
-		assertEquals(b1.bi3(), Arrays.asList());
-		assertEquals(b2.bi3(), Arrays.asList(a2));
-		assertEquals(b3.bi3(), Arrays.asList());
+		assertNull(a1.getBi3());
+		assertSame(a2.getBi3(), b2);
+		assertEquals(b1.getBi3s(), Arrays.asList());
+		assertEquals(b1.getBi3List(), Arrays.asList());
+		assertEquals(b2.getBi3s(), Arrays.asList(a2));
+		assertEquals(b2.getBi3List(), Arrays.asList(a2));
+		assertEquals(b3.getBi3s(), Arrays.asList());
+		assertEquals(b3.getBi3List(), Arrays.asList());
 
 		a2.setBi3(b3);
 
-		assertNull(a1.bi3());
-		assertSame(a2.bi3(), b3);
-		assertEquals(b1.bi3(), Arrays.asList());
-		assertEquals(b2.bi3(), Arrays.asList());
-		assertEquals(b3.bi3(), Arrays.asList(a2));
+		assertNull(a1.getBi3());
+		assertSame(a2.getBi3(), b3);
+		assertEquals(b1.getBi3s(), Arrays.asList());
+		assertEquals(b1.getBi3List(), Arrays.asList());
+		assertEquals(b2.getBi3s(), Arrays.asList());
+		assertEquals(b2.getBi3List(), Arrays.asList());
+		assertEquals(b3.getBi3s(), Arrays.asList(a2));
+		assertEquals(b3.getBi3List(), Arrays.asList(a2));
 
 		a1.setBi3(b3);
 		a3.setBi3(b3);
 
-		assertSame(a1.bi3(), b3);
-		assertSame(a2.bi3(), b3);
-		assertSame(a3.bi3(), b3);
-		assertEquals(b1.bi3(), Arrays.asList());
-		assertEquals(b2.bi3(), Arrays.asList());
-		assertEquals(b3.bi3(), Arrays.asList(a2, a1, a3));
+		assertSame(a1.getBi3(), b3);
+		assertSame(a2.getBi3(), b3);
+		assertSame(a3.getBi3(), b3);
+		assertEquals(b1.getBi3s(), Arrays.asList());
+		assertEquals(b1.getBi3List(), Arrays.asList());
+		assertEquals(b2.getBi3s(), Arrays.asList());
+		assertEquals(b2.getBi3List(), Arrays.asList());
+		assertEquals(b3.getBi3s(), Arrays.asList(a2, a1, a3));
+		assertEquals(b3.getBi3List(), Arrays.asList(a2, a1, a3));
 
 		a2.setBi3(b1);
 
-		assertSame(a1.bi3(), b3);
-		assertSame(a2.bi3(), b1);
-		assertSame(a3.bi3(), b3);
-		assertEquals(b1.bi3(), Arrays.asList(a2));
-		assertEquals(b2.bi3(), Arrays.asList());
-		assertEquals(b3.bi3(), Arrays.asList(a1, a3));
+		assertSame(a1.getBi3(), b3);
+		assertSame(a2.getBi3(), b1);
+		assertSame(a3.getBi3(), b3);
+		assertEquals(b1.getBi3s(), Arrays.asList(a2));
+		assertEquals(b1.getBi3List(), Arrays.asList(a2));
+		assertEquals(b2.getBi3s(), Arrays.asList());
+		assertEquals(b2.getBi3List(), Arrays.asList());
+		assertEquals(b3.getBi3s(), Arrays.asList(a1, a3));
+		assertEquals(b3.getBi3List(), Arrays.asList(a1, a3));
 
 		try {
 			a2.setBi3(null);
@@ -241,7 +262,7 @@ public class All extends AbstractTests {
 
 
 	/**
-	 * rel A.bi4? <-> B.bi4;
+	 * rel A.Bi4? <-> B.Bi4;
 	 */
 	private void testBi4() {
 		testBi41();
@@ -256,10 +277,10 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi4(b1);
 
-		assertNull(a1.bi4());
-		assertSame(a2.bi4(), b1);
-		assertSame(b1.bi4(), a2);
-		assertNull(b2.bi4());
+		assertNull(a1.getBi4());
+		assertSame(a2.getBi4(), b1);
+		assertSame(b1.getBi4(), a2);
+		assertNull(b2.getBi4());
 	}
 	private void testBi42() {
 		// Init
@@ -269,16 +290,16 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi4(b2);
 
-		assertNull(a1.bi4());
-		assertSame(a2.bi4(), b2);
-		assertNull(b1.bi4());
-		assertSame(b2.bi4(), a2);
+		assertNull(a1.getBi4());
+		assertSame(a2.getBi4(), b2);
+		assertNull(b1.getBi4());
+		assertSame(b2.getBi4(), a2);
 	}
 
 
 
 	/**
-	 * rel A.bi5? <-> B.bi5?;
+	 * rel A.Bi5? <-> B.Bi5?;
 	 */
 	private void testBi5() {
 		testBi51();
@@ -293,10 +314,10 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi5(b1);
 
-		assertNull(a1.bi5());
-		assertSame(a2.bi5(), b1);
-		assertSame(b1.bi5(), a2);
-		assertNull(b2.bi5());
+		assertNull(a1.getBi5());
+		assertSame(a2.getBi5(), b1);
+		assertSame(b1.getBi5(), a2);
+		assertNull(b2.getBi5());
 	}
 	private void testBi52() {
 		// Init
@@ -306,62 +327,77 @@ public class All extends AbstractTests {
 		// Change
 		a2.setBi5(b2);
 
-		assertNull(a1.bi5());
-		assertSame(a2.bi5(), b2);
-		assertNull(b1.bi5());
-		assertSame(b2.bi5(), a2);
+		assertNull(a1.getBi5());
+		assertSame(a2.getBi5(), b2);
+		assertNull(b1.getBi5());
+		assertSame(b2.getBi5(), a2);
 	}
 
 
 
 	/**
-	 * rel A.bi6? <-> B.bi6*;
+	 * rel A.Bi6? <-> B.Bi6*;
 	 */
 	private void testBi6() {
 		setup();
 		a2.setBi6(b2);
 
-		assertNull(a1.bi6());
-		assertSame(a2.bi6(), b2);
-		assertEquals(b1.bi6(), Arrays.asList());
-		assertEquals(b2.bi6(), Arrays.asList(a2));
-		assertEquals(b3.bi6(), Arrays.asList());
+		assertNull(a1.getBi6());
+		assertSame(a2.getBi6(), b2);
+		assertEquals(b1.getBi6s(), Arrays.asList());
+		assertEquals(b1.getBi6List(), Arrays.asList());
+		assertEquals(b2.getBi6s(), Arrays.asList(a2));
+		assertEquals(b2.getBi6List(), Arrays.asList(a2));
+		assertEquals(b3.getBi6s(), Arrays.asList());
+		assertEquals(b3.getBi6List(), Arrays.asList());
 
 		a2.setBi6(b3);
 
-		assertNull(a1.bi6());
-		assertSame(a2.bi6(), b3);
-		assertEquals(b1.bi6(), Arrays.asList());
-		assertEquals(b2.bi6(), Arrays.asList());
-		assertEquals(b3.bi6(), Arrays.asList(a2));
+		assertNull(a1.getBi6());
+		assertSame(a2.getBi6(), b3);
+		assertEquals(b1.getBi6s(), Arrays.asList());
+		assertEquals(b1.getBi6List(), Arrays.asList());
+		assertEquals(b2.getBi6s(), Arrays.asList());
+		assertEquals(b2.getBi6List(), Arrays.asList());
+		assertEquals(b3.getBi6s(), Arrays.asList(a2));
+		assertEquals(b3.getBi6List(), Arrays.asList(a2));
 
 		a1.setBi6(b3);
 		a3.setBi6(b3);
 
-		assertSame(a1.bi6(), b3);
-		assertSame(a2.bi6(), b3);
-		assertSame(a3.bi6(), b3);
-		assertEquals(b1.bi6(), Arrays.asList());
-		assertEquals(b2.bi6(), Arrays.asList());
-		assertEquals(b3.bi6(), Arrays.asList(a2, a1, a3));
+		assertSame(a1.getBi6(), b3);
+		assertSame(a2.getBi6(), b3);
+		assertSame(a3.getBi6(), b3);
+		assertEquals(b1.getBi6s(), Arrays.asList());
+		assertEquals(b1.getBi6List(), Arrays.asList());
+		assertEquals(b2.getBi6s(), Arrays.asList());
+		assertEquals(b2.getBi6List(), Arrays.asList());
+		assertEquals(b3.getBi6s(), Arrays.asList(a2, a1, a3));
+		assertEquals(b3.getBi6List(), Arrays.asList(a2, a1, a3));
 
 		a2.setBi6(b1);
 
-		assertSame(a1.bi6(), b3);
-		assertSame(a2.bi6(), b1);
-		assertSame(a3.bi6(), b3);
-		assertEquals(b1.bi6(), Arrays.asList(a2));
-		assertEquals(b2.bi6(), Arrays.asList());
-		assertEquals(b3.bi6(), Arrays.asList(a1, a3));
+		assertSame(a1.getBi6(), b3);
+		assertSame(a2.getBi6(), b1);
+		assertSame(a3.getBi6(), b3);
+		assertEquals(b1.getBi6s(), Arrays.asList(a2));
+		assertEquals(b1.getBi6List(), Arrays.asList(a2));
+		assertEquals(b2.getBi6s(), Arrays.asList());
+		assertEquals(b2.getBi6List(), Arrays.asList());
+		assertEquals(b3.getBi6s(), Arrays.asList(a1, a3));
+		assertEquals(b3.getBi6List(), Arrays.asList(a1, a3));
 
 		a2.clearBi6();
 
-		assertSame(a1.bi6(), b3);
-		assertNull(a2.bi6());
-		assertSame(a3.bi6(), b3);
-		assertEquals(b1.bi6(), Arrays.asList());
-		assertEquals(b2.bi6(), Arrays.asList());
-		assertEquals(b3.bi6(), Arrays.asList(a1, a3));
+		assertSame(a1.getBi6(), b3);
+		assertNull(a2.getBi6());
+		assertSame(a3.getBi6(), b3);
+		assertEquals(b1.getBi6s(), Arrays.asList());
+		assertEquals(b1.getBi6List(), Arrays.asList());
+		assertEquals(b2.getBi6s(), Arrays.asList());
+		assertEquals(b2.getBi6List(), Arrays.asList());
+		assertEquals(b3.getBi6s(), Arrays.asList(a1, a3));
+		assertEquals(b3.getBi6List(), Arrays.asList(a1, a3));
 
 		assertTrue(a1.hasBi6());
 		assertFalse(a2.hasBi6());
@@ -371,165 +407,203 @@ public class All extends AbstractTests {
 
 
 	/**
-	 * rel A.bi7* <-> B.bi7;
+	 * rel A.Bi7* <-> B.Bi7;
 	 */
 	private void testBi7() {
 		setup();
-		a2.addToBi7(b2);
-
-		assertEquals(a1.bi7(), Arrays.asList());
-		assertEquals(a2.bi7(), Arrays.asList(b2));
-		assertNull(b1.bi7());
-		assertSame(b2.bi7(), a2);
-		assertNull(b3.bi7());
-
-		a2.addToBi7(b3);
-		a1.addToBi7(b2);
-
-		assertEquals(a1.bi7(), Arrays.asList(b2));
-		assertEquals(a2.bi7(), Arrays.asList(b3));
-		assertNull(b1.bi7());
-		assertSame(b2.bi7(), a1);
-		assertSame(b3.bi7(), a2);
-
-		a1.addToBi7(b1);
-
-		assertEquals(a1.bi7(), Arrays.asList(b2, b1));
-		assertEquals(a2.bi7(), Arrays.asList(b3));
-		assertSame(b1.bi7(), a1);
-		assertSame(b2.bi7(), a1);
-		assertSame(b3.bi7(), a2);
-
-		a1.addToBi7(b1);
-
-		assertEquals(a1.bi7(), Arrays.asList(b2, b1));
-		assertEquals(a2.bi7(), Arrays.asList(b3));
-		assertSame(b1.bi7(), a1);
-		assertSame(b2.bi7(), a1);
-		assertSame(b3.bi7(), a2);
-
-		a1.removeFromBi7(b1);
-
-		assertEquals(a1.bi7(), Arrays.asList(b2));
-		assertEquals(a2.bi7(), Arrays.asList(b3));
-		assertNull(b1.bi7());
-		assertSame(b2.bi7(), a1);
-		assertSame(b3.bi7(), a2);
+		a2.addBi7(b2);
+
+		assertEquals(a1.getBi7s(), Arrays.asList());
+		assertEquals(a1.getBi7List(), Arrays.asList());
+		assertEquals(a2.getBi7s(), Arrays.asList(b2));
+		assertEquals(a2.getBi7List(), Arrays.asList(b2));
+		assertNull(b1.getBi7());
+		assertSame(b2.getBi7(), a2);
+		assertNull(b3.getBi7());
+
+		a2.addBi7(b3);
+		a1.addBi7(b2);
+
+		assertEquals(a1.getBi7s(), Arrays.asList(b2));
+		assertEquals(a1.getBi7List(), Arrays.asList(b2));
+		assertEquals(a2.getBi7s(), Arrays.asList(b3));
+		assertEquals(a2.getBi7List(), Arrays.asList(b3));
+		assertNull(b1.getBi7());
+		assertSame(b2.getBi7(), a1);
+		assertSame(b3.getBi7(), a2);
+
+		a1.addBi7(b1);
+
+		assertEquals(a1.getBi7s(), Arrays.asList(b2, b1));
+		assertEquals(a1.getBi7List(), Arrays.asList(b2, b1));
+		assertEquals(a2.getBi7s(), Arrays.asList(b3));
+		assertEquals(a2.getBi7List(), Arrays.asList(b3));
+		assertSame(b1.getBi7(), a1);
+		assertSame(b2.getBi7(), a1);
+		assertSame(b3.getBi7(), a2);
+
+		a1.addBi7(b1);
+
+		assertEquals(a1.getBi7s(), Arrays.asList(b2, b1));
+		assertEquals(a1.getBi7List(), Arrays.asList(b2, b1));
+		assertEquals(a2.getBi7s(), Arrays.asList(b3));
+		assertEquals(a2.getBi7List(), Arrays.asList(b3));
+		assertSame(b1.getBi7(), a1);
+		assertSame(b2.getBi7(), a1);
+		assertSame(b3.getBi7(), a2);
+
+		a1.removeBi7(b1);
+
+		assertEquals(a1.getBi7s(), Arrays.asList(b2));
+		assertEquals(a1.getBi7List(), Arrays.asList(b2));
+		assertEquals(a2.getBi7s(), Arrays.asList(b3));
+		assertEquals(a2.getBi7List(), Arrays.asList(b3));
+		assertNull(b1.getBi7());
+		assertSame(b2.getBi7(), a1);
+		assertSame(b3.getBi7(), a2);
 	}
 
 
 
 	/**
-	 * rel A.bi8* <-> B.bi8?;
+	 * rel A.Bi8* <-> B.Bi8?;
 	 */
 	private void testBi8() {
 		setup();
-		a2.addToBi8(b2);
-
-		assertEquals(a1.bi8(), Arrays.asList());
-		assertEquals(a2.bi8(), Arrays.asList(b2));
-		assertNull(b1.bi8());
-		assertSame(b2.bi8(), a2);
-		assertNull(b3.bi8());
-
-		a2.addToBi8(b3);
-		a1.addToBi8(b2);
-
-		assertEquals(a1.bi8(), Arrays.asList(b2));
-		assertEquals(a2.bi8(), Arrays.asList(b3));
-		assertNull(b1.bi8());
-		assertSame(b2.bi8(), a1);
-		assertSame(b3.bi8(), a2);
-
-		a1.addToBi8(b1);
-
-		assertEquals(a1.bi8(), Arrays.asList(b2, b1));
-		assertEquals(a2.bi8(), Arrays.asList(b3));
-		assertSame(b1.bi8(), a1);
-		assertSame(b2.bi8(), a1);
-		assertSame(b3.bi8(), a2);
-
-		a1.addToBi8(b1);
-
-		assertEquals(a1.bi8(), Arrays.asList(b2, b1));
-		assertEquals(a2.bi8(), Arrays.asList(b3));
-		assertSame(b1.bi8(), a1);
-		assertSame(b2.bi8(), a1);
-		assertSame(b3.bi8(), a2);
-
-		a1.removeFromBi8(b1);
-
-		assertEquals(a1.bi8(), Arrays.asList(b2));
-		assertEquals(a2.bi8(), Arrays.asList(b3));
-		assertNull(b1.bi8());
-		assertSame(b2.bi8(), a1);
-		assertSame(b3.bi8(), a2);
+		a2.addBi8(b2);
+
+		assertEquals(a1.getBi8s(), Arrays.asList());
+		assertEquals(a1.getBi8List(), Arrays.asList());
+		assertEquals(a2.getBi8s(), Arrays.asList(b2));
+		assertEquals(a2.getBi8List(), Arrays.asList(b2));
+		assertNull(b1.getBi8());
+		assertSame(b2.getBi8(), a2);
+		assertNull(b3.getBi8());
+
+		a2.addBi8(b3);
+		a1.addBi8(b2);
+
+		assertEquals(a1.getBi8s(), Arrays.asList(b2));
+		assertEquals(a1.getBi8List(), Arrays.asList(b2));
+		assertEquals(a2.getBi8s(), Arrays.asList(b3));
+		assertEquals(a2.getBi8List(), Arrays.asList(b3));
+		assertNull(b1.getBi8());
+		assertSame(b2.getBi8(), a1);
+		assertSame(b3.getBi8(), a2);
+
+		a1.addBi8(b1);
+
+		assertEquals(a1.getBi8s(), Arrays.asList(b2, b1));
+		assertEquals(a1.getBi8List(), Arrays.asList(b2, b1));
+		assertEquals(a2.getBi8s(), Arrays.asList(b3));
+		assertEquals(a2.getBi8List(), Arrays.asList(b3));
+		assertSame(b1.getBi8(), a1);
+		assertSame(b2.getBi8(), a1);
+		assertSame(b3.getBi8(), a2);
+
+		a1.addBi8(b1);
+
+		assertEquals(a1.getBi8s(), Arrays.asList(b2, b1));
+		assertEquals(a1.getBi8List(), Arrays.asList(b2, b1));
+		assertEquals(a2.getBi8s(), Arrays.asList(b3));
+		assertEquals(a2.getBi8List(), Arrays.asList(b3));
+		assertSame(b1.getBi8(), a1);
+		assertSame(b2.getBi8(), a1);
+		assertSame(b3.getBi8(), a2);
+
+		a1.removeBi8(b1);
+
+		assertEquals(a1.getBi8s(), Arrays.asList(b2));
+		assertEquals(a1.getBi8List(), Arrays.asList(b2));
+		assertEquals(a2.getBi8s(), Arrays.asList(b3));
+		assertEquals(a2.getBi8List(), Arrays.asList(b3));
+		assertNull(b1.getBi8());
+		assertSame(b2.getBi8(), a1);
+		assertSame(b3.getBi8(), a2);
 	}
 
 
 
 	/**
-	 * rel A.bi9* <-> B.bi9*;
+	 * rel A.Bi9* <-> B.Bi9*;
 	 */
 	private void testBi9() {
 		setup();
-		a1.addToBi9(b1);
-		a1.addToBi9(b2);
-
-		assertEquals(a1.bi9(), Arrays.asList(b1, b2));
-		assertEquals(a2.bi9(), Arrays.asList());
-		assertEquals(a3.bi9(), Arrays.asList());
-		assertEquals(b1.bi9(), Arrays.asList(a1));
-		assertEquals(b2.bi9(), Arrays.asList(a1));
-		assertEquals(b3.bi9(), Arrays.asList());
-	
-		b3.addToBi9(a1);
-		b3.addToBi9(a3);
-		b3.addToBi9(a1);
-
-		assertEquals(a1.bi9(), Arrays.asList(b1, b2, b3, b3));
-		assertEquals(a2.bi9(), Arrays.asList());
-		assertEquals(a3.bi9(), Arrays.asList(b3));
-		assertEquals(b1.bi9(), Arrays.asList(a1));
-		assertEquals(b2.bi9(), Arrays.asList(a1));
-		assertEquals(b3.bi9(), Arrays.asList(a1, a3, a1));
-
-		b3.removeFromBi9(a1);
-
-		assertEquals(a1.bi9(), Arrays.asList(b1, b2, b3));
-		assertEquals(a2.bi9(), Arrays.asList());
-		assertEquals(a3.bi9(), Arrays.asList(b3));
-		assertEquals(b1.bi9(), Arrays.asList(a1));
-		assertEquals(b2.bi9(), Arrays.asList(a1));
-		assertEquals(b3.bi9(), Arrays.asList(a3, a1));
+		a1.addBi9(b1);
+		a1.addBi9(b2);
+
+		assertEquals(a1.getBi9s(), Arrays.asList(b1, b2));
+		assertEquals(a1.getBi9List(), Arrays.asList(b1, b2));
+		assertEquals(a2.getBi9s(), Arrays.asList());
+		assertEquals(a2.getBi9List(), Arrays.asList());
+		assertEquals(a3.getBi9s(), Arrays.asList());
+		assertEquals(a3.getBi9List(), Arrays.asList());
+		assertEquals(b1.getBi9s(), Arrays.asList(a1));
+		assertEquals(b1.getBi9List(), Arrays.asList(a1));
+		assertEquals(b2.getBi9s(), Arrays.asList(a1));
+		assertEquals(b2.getBi9List(), Arrays.asList(a1));
+		assertEquals(b3.getBi9s(), Arrays.asList());
+		assertEquals(b3.getBi9List(), Arrays.asList());
+
+		b3.addBi9(a1);
+		b3.addBi9(a3);
+		b3.addBi9(a1);
+
+		assertEquals(a1.getBi9s(), Arrays.asList(b1, b2, b3, b3));
+		assertEquals(a1.getBi9List(), Arrays.asList(b1, b2, b3, b3));
+		assertEquals(a2.getBi9s(), Arrays.asList());
+		assertEquals(a2.getBi9List(), Arrays.asList());
+		assertEquals(a3.getBi9s(), Arrays.asList(b3));
+		assertEquals(a3.getBi9List(), Arrays.asList(b3));
+		assertEquals(b1.getBi9s(), Arrays.asList(a1));
+		assertEquals(b1.getBi9List(), Arrays.asList(a1));
+		assertEquals(b2.getBi9s(), Arrays.asList(a1));
+		assertEquals(b2.getBi9List(), Arrays.asList(a1));
+		assertEquals(b3.getBi9s(), Arrays.asList(a1, a3, a1));
+		assertEquals(b3.getBi9List(), Arrays.asList(a1, a3, a1));
+
+		b3.removeBi9(a1);
+
+		assertEquals(a1.getBi9s(), Arrays.asList(b1, b2, b3));
+		assertEquals(a1.getBi9List(), Arrays.asList(b1, b2, b3));
+		assertEquals(a2.getBi9s(), Arrays.asList());
+		assertEquals(a2.getBi9List(), Arrays.asList());
+		assertEquals(a3.getBi9s(), Arrays.asList(b3));
+		assertEquals(a3.getBi9List(), Arrays.asList(b3));
+		assertEquals(b1.getBi9s(), Arrays.asList(a1));
+		assertEquals(b1.getBi9List(), Arrays.asList(a1));
+		assertEquals(b2.getBi9s(), Arrays.asList(a1));
+		assertEquals(b2.getBi9List(), Arrays.asList(a1));
+		assertEquals(b3.getBi9s(), Arrays.asList(a3, a1));
+		assertEquals(b3.getBi9List(), Arrays.asList(a3, a1));
 	}
 
 
 	public void testImmutableList() {
 		setup();
 
-		a1.addToDi3(b1);
-		a1.addToDi3(b2);
+		a1.addDi3(b1);
+		a1.addDi3(b2);
 		try {
-			a1.di3().add(b3);
+			a1.getDi3s().add(b3);
 			assertException();
 		} catch (Exception e) {
 			// OK
 		}
 
-		a1.addToBi7(b1);
-		a1.addToBi7(b2);
+		a1.addBi7(b1);
+		a1.addBi7(b2);
 		try {
-			a1.bi7().add(b3);
+			a1.getBi7s().add(b3);
 			assertException();
 		} catch (Exception e) {
 			// OK
 		}
 
-		a1.addToBi9(b1);
-		a1.addToBi9(b2);
+		a1.addBi9(b1);
+		a1.addBi9(b2);
 		try {
-			a1.bi9().add(b3);
+			a1.getBi9s().add(b3);
 			assertException();
 		} catch (Exception e) {
 			// OK
@@ -552,4 +626,4 @@ public class All extends AbstractTests {
 		r.addB(b2);
 		r.addB(b3);
 	}
-}
\ No newline at end of file
+}
diff --git a/tests/valid/All.relast b/tests/valid/All.relast
index 56fe6de2fec686894cc1b3ee9c111040bafb468e..51f3c621f8e71ec70412e8b88bc0802a6d37f7a0 100644
--- a/tests/valid/All.relast
+++ b/tests/valid/All.relast
@@ -2,18 +2,18 @@ Root ::= A* B*;
 A ::= <Name>;
 B ::= <Name>;
 
-rel A.di1  -> B;
-rel A.di2? -> B;
-rel A.di3* -> B;
+rel A.Di1  -> B;
+rel A.Di2? -> B;
+rel A.Di3* -> B;
 
-rel A.bi1 <-> B.bi1;
-rel A.bi2 <-> B.bi2?;
-rel A.bi3 <-> B.bi3*;
+rel A.Bi1 <-> B.Bi1;
+rel A.Bi2 <-> B.Bi2?;
+rel A.Bi3 <-> B.Bi3*;
 
-rel A.bi4? <-> B.bi4;
-rel A.bi5? <-> B.bi5?;
-rel A.bi6? <-> B.bi6*;
+rel A.Bi4? <-> B.Bi4;
+rel A.Bi5? <-> B.Bi5?;
+rel A.Bi6? <-> B.Bi6*;
 
-rel A.bi7* <-> B.bi7;
-rel A.bi8* <-> B.bi8?;
-rel A.bi9* <-> B.bi9*;
+rel A.Bi7* <-> B.Bi7;
+rel A.Bi8* <-> B.Bi8?;
+rel A.Bi9* <-> B.Bi9*;
diff --git a/tests/valid/LowerBounds.java b/tests/valid/LowerBounds.java
index 4fe5ea689f6db45267a1a3a49dd3b5c8683c69c4..2c8d0b2ad613299850985a9b796d0a4abd415e4b 100644
--- a/tests/valid/LowerBounds.java
+++ b/tests/valid/LowerBounds.java
@@ -10,9 +10,9 @@ public class LowerBounds extends AbstractTests {
 	 * A ::= <Name> [C];
 	 * B ::= <Name>;
 	 * C ::= <Name>;
-	 * rel A.b -> B;
-	 * rel B.c <-> C.b;
-	 * rel Root.aa? -> A;
+	 * rel A.Br -> B;
+	 * rel B.Cr <-> C.Br;
+	 * rel Root.Aa? -> A;
 	 */
 	public void test() {
 		Root r = new Root();
@@ -29,19 +29,19 @@ public class LowerBounds extends AbstractTests {
 
 		assertTrue(r.violatesLowerBounds());
 
-		a1.setB(b1);
-		a2.setB(b2);
-		b1.setC(c1);
-		b2.setC(c2);
+		a1.setBr(b1);
+		a2.setBr(b2);
+		b1.setCr(c1);
+		b2.setCr(c2);
 
 		assertFalse(r.violatesLowerBounds());
 
-		b2.setC(c1);
+		b2.setCr(c1);
 
 		assertTrue(r.violatesLowerBounds());
 
-		b1.setC(c2);
+		b1.setCr(c2);
 
 		assertFalse(r.violatesLowerBounds());
 	}
-}
\ No newline at end of file
+}
diff --git a/tests/valid/LowerBounds.relast b/tests/valid/LowerBounds.relast
index 43b2340af7e3952e31d0a7c34410c133542f861a..27932b75cd413857627f39133adcf7f4382753da 100644
--- a/tests/valid/LowerBounds.relast
+++ b/tests/valid/LowerBounds.relast
@@ -3,6 +3,6 @@ A ::= <Name> [C];
 B ::= <Name>;
 C ::= <Name>;
 
-rel A.b -> B;
-rel B.c <-> C.b;
-rel Root.aa? -> A;
+rel A.Br -> B;
+rel B.Cr <-> C.Br;
+rel Root.Aa? -> A;