generalize distance measure (#21)

and add two additional measures
Interactive-Intelligent-Systems · Dec 27, 2023 · 98181fe · 98181fe
1 parent 938cffe
commit 98181fe
Show file tree

Hide file tree

Showing 12 changed files with 206 additions and 67 deletions.
diff --git a/AgreementScenarios.md b/AgreementScenarios.md
@@ -41,7 +41,8 @@ Semantics grounded = new Semantics(SemanticsType.GROUNDED);
 semantics.add(stage);
 semantics.add(preferred);
 semantics.add(grounded);
-aScenario = new AgreementScenario(framework, topic, semantics);
+CombinedDistance measure = new CombinedDistance();
+aScenario = new AgreementScenario(framework, topic, semantics, measure);
 ```
 The agreement scenario has the argumentation framework
 ({a, b, c, d, e}, {(e, a), (d, b), (b, d), (d, c), (c, d), (d, d), (e, e)}), the topic {a, b, c} and three agents with
@@ -167,7 +168,7 @@ vTopic.add(a);
 vTopic.add(b);
 vTopic.add(c);
 vTopic.add(d);
-ValueBasedAgreementScenario vbScenario = new ValueBasedAgreementScenario(vbFramework, vTopic, preferredSemantics);
+ValueBasedAgreementScenario vbScenario = new ValueBasedAgreementScenario(vbFramework, vTopic, preferredSemantics, measure);
 ```
 
 For a VAAS, we can determine the degrees of satisfaction and agreements, in the same way we do this for an AAS:

diff --git a/src/main/java/diarg/AgreementScenario.java b/src/main/java/diarg/AgreementScenario.java
@@ -3,6 +3,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import com.google.common.math.Quantiles;
+import diarg.distances.DistanceMeasure;
 import net.sf.tweety.arg.dung.semantics.Extension;
 import net.sf.tweety.arg.dung.syntax.Argument;
 import net.sf.tweety.arg.dung.syntax.Attack;
@@ -24,6 +25,7 @@ public class AgreementScenario {
     private DungTheory argumentationFramework;
     private Collection<Argument> topic;
     private ArrayList<Semantics> semantics;
+    private DistanceMeasure distanceMeasure;
 
     /**
      * Returns the agreement scenario's argumentation framework.
@@ -52,7 +54,8 @@ public ArrayList<Semantics> getSemantics() {
     public AgreementScenario (
             DungTheory argumentationFramework,
             Collection<Argument> topic,
-            ArrayList<Semantics> semantics
+            ArrayList<Semantics> semantics,
+            DistanceMeasure distanceMeasure
     ) {
         try {
             if (!argumentationFramework.containsAll(topic)) {
@@ -64,6 +67,7 @@ public AgreementScenario (
         this.argumentationFramework = argumentationFramework;
         this.topic = topic;
         this.semantics = semantics;
+        this.distanceMeasure = distanceMeasure;
     }
 
     /**
@@ -136,7 +140,7 @@ public double determineSatisfaction(int index1, int index2) {
         double greatestSimilarity = 0;
         for(Extension extension1: extensions1) {
             for(Extension extension2: extensions2) {
-                double similarity = Utils.determineSetSimilarity(extension1, extension2, topic);
+                double similarity = distanceMeasure.determineDistance(extension1, extension2, topic);
                 if(similarity > greatestSimilarity) greatestSimilarity = similarity;
             }
         }
@@ -157,7 +161,7 @@ public double determineMinimalAgreement() {
             for(Semantics currentSemantics: semantics) {
                 double bestExtensionSimilarity = 0;
                 for(Extension extension: currentSemantics.getModels(argumentationFramework)) {
-                    double extensionSimilarity = Utils.determineSetSimilarity(extension, currentArgumentSet, topic);
+                    double extensionSimilarity = distanceMeasure.determineDistance(extension, currentArgumentSet, topic);
                     if(extensionSimilarity > bestExtensionSimilarity) {
                         bestExtensionSimilarity = extensionSimilarity;
                     }
@@ -185,7 +189,7 @@ public double determineMeanAgreement() {
             for(Semantics currentSemantics: semantics) {
                 double bestExtensionSimilarity = 0;
                 for(Extension extension: currentSemantics.getModels(argumentationFramework)) {
-                    double extensionSimilarity = Utils.determineSetSimilarity(extension, currentArgumentSet, topic);
+                    double extensionSimilarity = distanceMeasure.determineDistance(extension, currentArgumentSet, topic);
                     if(extensionSimilarity > bestExtensionSimilarity) {
                         bestExtensionSimilarity = extensionSimilarity;
                     }
@@ -211,7 +215,7 @@ public double determineMedianAgreement() {
             for(Semantics currentSemantics: semantics) {
                 double bestExtensionSimilarity = 0;
                 for(Extension extension: currentSemantics.getModels(argumentationFramework)) {
-                    double extensionSimilarity = Utils.determineSetSimilarity(extension, currentArgumentSet, topic);
+                    double extensionSimilarity = distanceMeasure.determineDistance(extension, currentArgumentSet, topic);
                     if(extensionSimilarity > bestExtensionSimilarity) {
                         bestExtensionSimilarity = extensionSimilarity;
                     }

diff --git a/src/main/java/diarg/Utils.java b/src/main/java/diarg/Utils.java
@@ -110,34 +110,6 @@ public static Collection<Argument> reachablyDefendedRanges(Collection<Argument>
         return reachablyDefendedRange;
     }
 
-    /**
-     * Determines the similarity between two sets of arguments, given a "base" set, using a simple similarity measure:
-     * (|arguments in base set and in set1 and set2| + |arguments in base set and neither in set1 nor in set two|)
-     * divided by |arguments in base set|
-     * @param set1 Set of arguments 1
-     * @param set2 Set of arguments 2
-     * @param baseSet Base set
-     * @return The similarity between the sets
-     */
-    public static double determineSetSimilarity(
-            Collection<Argument> set1,
-            Collection<Argument> set2,
-            Collection<Argument> baseSet) {
-        if (baseSet.size() == 0) {
-            return 1;
-        }
-        Collection<Argument> setInAll = new ArrayList<>();
-        Collection<Argument> setInNone = new ArrayList<>();
-        for(Argument argument: baseSet) {
-            if(set1.contains(argument) && set2.contains(argument)) {
-                setInAll.add(argument);
-            } else if(!set1.contains(argument) && !set2.contains(argument)){
-                setInNone.add(argument);
-            }
-        }
-        return ((setInAll.size() + setInNone.size()) / (double) baseSet.size());
-    }
-
     /**
      * Determines the maximally monotonic extensions (w.r.t. set inclusion) of a list of target extensions w.r.t. to a
      * list of base extensions

diff --git a/src/main/java/diarg/distances/CombinedDistance.java b/src/main/java/diarg/distances/CombinedDistance.java
@@ -0,0 +1,34 @@
+package diarg.distances;
+
+import net.sf.tweety.arg.dung.syntax.Argument;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class CombinedDistance extends DistanceMeasure {
+    /**
+     * Determines the similarity between two sets of arguments, given a "base" set, using a simple similarity measure:
+     * (|arguments in base set and in set1 and set2| + |arguments in base set and neither in set1 nor in set two|)
+     * divided by |arguments in base set|
+     * @param set1 Set of arguments 1
+     * @param set2 Set of arguments 2
+     * @param baseSet Base set
+     * @return The similarity between the sets
+     */
+    @Override
+    public double determineDistance(Collection<Argument> set1, Collection<Argument> set2, Collection<Argument> baseSet) {
+        if (baseSet.size() == 0) {
+            return 1;
+        }
+        Collection<Argument> setInAll = new ArrayList<>();
+        Collection<Argument> setInNone = new ArrayList<>();
+        for(Argument argument: baseSet) {
+            if(set1.contains(argument) && set2.contains(argument) && baseSet.contains(argument)) {
+                setInAll.add(argument);
+            } else if(!set1.contains(argument) && !set2.contains(argument) && baseSet.contains(argument)){
+                setInNone.add(argument);
+            }
+        }
+        return ((setInAll.size() + setInNone.size()) / (double) baseSet.size());
+    }
+}
diff --git a/src/main/java/diarg/distances/DistanceMeasure.java b/src/main/java/diarg/distances/DistanceMeasure.java
@@ -0,0 +1,16 @@
+package diarg.distances;
+
+import net.sf.tweety.arg.dung.syntax.Argument;
+
+import java.util.Collection;
+
+/**
+ * Abstract distance measure between sets
+ * @author Timotheus Kampik
+ */
+public abstract class DistanceMeasure {
+
+        public abstract double determineDistance(Collection<Argument> set1,
+                                                 Collection<Argument> set2,
+                                                 Collection<Argument> baseSet);
+}
diff --git a/src/main/java/diarg/distances/InDistance.java b/src/main/java/diarg/distances/InDistance.java
@@ -0,0 +1,36 @@
+package diarg.distances;
+
+import net.sf.tweety.arg.dung.syntax.Argument;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class InDistance extends DistanceMeasure {
+    /**
+     * Determines the similarity between two sets of arguments, given a "base" set, considering only the arguments in
+     * the sets:
+     * (|arguments in base set and in set1 and set2|)
+     * divided by |arguments in base set and in either set1, set2, or both|
+     * @param set1 Set of arguments 1
+     * @param set2 Set of arguments 2
+     * @param baseSet Base set
+     * @return The similarity between the sets
+     */
+    @Override
+    public double determineDistance(Collection<Argument> set1, Collection<Argument> set2, Collection<Argument> baseSet) {
+        Collection<Argument> setInAll = new ArrayList<>();
+        Collection<Argument> setInSome = new ArrayList<>();
+        for(Argument argument: baseSet) {
+            if(set1.contains(argument) && set2.contains(argument) && baseSet.contains(argument)) {
+                setInAll.add(argument);
+                setInSome.add(argument);
+            } else if(baseSet.contains(argument) && (set1.contains(argument) || set2.contains(argument))){
+                setInSome.add(argument);
+            }
+        }
+        if (setInSome.size() == 0) {
+            return 1;
+        }
+        return setInAll.size() / (double) setInSome.size();
+    }
+}
diff --git a/src/main/java/diarg/distances/OutDistance.java b/src/main/java/diarg/distances/OutDistance.java
@@ -0,0 +1,36 @@
+package diarg.distances;
+
+import net.sf.tweety.arg.dung.syntax.Argument;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class OutDistance extends DistanceMeasure{
+    /**
+     * Determines the similarity between two sets of arguments, given a "base" set, considering only the arguments in
+     * the sets:
+     * (|arguments in base set and in the complements of set1 of set2 w.r.t the base set|)
+     * divided by |arguments in base set and in either of thee complements|
+     * @param set1 Set of arguments 1
+     * @param set2 Set of arguments 2
+     * @param baseSet Base set
+     * @return The similarity between the sets
+     */
+    @Override
+    public double determineDistance(Collection<Argument> set1, Collection<Argument> set2, Collection<Argument> baseSet) {
+        Collection<Argument> setInAllComplements = new ArrayList<>();
+        Collection<Argument> setInSomeComplements = new ArrayList<>();
+        for(Argument argument: baseSet) {
+            if(!set1.contains(argument) && !set2.contains(argument) && baseSet.contains(argument)) {
+                setInAllComplements.add(argument);
+                setInSomeComplements.add(argument);
+            } else if(baseSet.contains(argument) && (!set1.contains(argument) || !set2.contains(argument))){
+                setInSomeComplements.add(argument);
+            }
+        }
+        if (setInSomeComplements.size() == 0) {
+            return 1;
+        }
+        return setInAllComplements.size() / (double) setInSomeComplements.size();
+    }
+}
diff --git a/src/main/java/diarg/values/ValueBasedAgreementScenario.java b/src/main/java/diarg/values/ValueBasedAgreementScenario.java
@@ -2,6 +2,7 @@
 
 import diarg.AgreementScenario;
 import diarg.Semantics;
+import diarg.distances.DistanceMeasure;
 import diarg.enums.SemanticsType;
 import net.sf.tweety.arg.dung.semantics.Extension;
 import net.sf.tweety.arg.dung.syntax.Argument;
@@ -20,12 +21,13 @@ public class ValueBasedAgreementScenario {
     @Override
     public ValueBasedAgreementScenario clone() {
         Collection<Argument> clonedTopic = new ArrayList<>(this.topic);
-        return new ValueBasedAgreementScenario(this.vbFramework.clone(), clonedTopic, this.semantics);
+        return new ValueBasedAgreementScenario(this.vbFramework.clone(), clonedTopic, this.semantics, this.distanceMeasure);
     }
 
     ValueBasedTheory vbFramework;
     Collection<Argument> topic;
     Semantics semantics;
+    private DistanceMeasure distanceMeasure;
 
     public ValueBasedTheory getVbFramework() {
         return vbFramework;
@@ -39,10 +41,11 @@ public Semantics getSemantics() {
         return semantics;
     }
 
-    public ValueBasedAgreementScenario(ValueBasedTheory vbFramework, Collection<Argument> topic, Semantics semantics) {
+    public ValueBasedAgreementScenario(ValueBasedTheory vbFramework, Collection<Argument> topic, Semantics semantics, DistanceMeasure distanceMeasure) {
         this.vbFramework = vbFramework;
         this.topic = topic;
         this.semantics = semantics;
+        this.distanceMeasure = distanceMeasure;
     }
 
     /**
@@ -112,7 +115,7 @@ public AgreementScenario toAgreementScenario() {
             subjectiveSemantics.setSubjectiveExtensions(subjectiveExtensions);
             subjectiveSemanticsList.add(subjectiveSemantics);
         }
-        return new AgreementScenario(vbFramework.getDungTheory(), topic, subjectiveSemanticsList);
+        return new AgreementScenario(vbFramework.getDungTheory(), topic, subjectiveSemanticsList, distanceMeasure);
     }
 
     /**

diff --git a/src/test/java/diarg/AgreementScenarioTest.java b/src/test/java/diarg/AgreementScenarioTest.java
@@ -1,5 +1,6 @@
 package diarg;
 
+import diarg.distances.CombinedDistance;
 import diarg.enums.SemanticsType;
 import net.sf.tweety.arg.dung.semantics.Extension;
 import net.sf.tweety.arg.dung.syntax.Argument;
@@ -35,6 +36,7 @@ public class AgreementScenarioTest {
     Semantics preferred = new Semantics(SemanticsType.PREFERRED);
     Semantics grounded = new Semantics(SemanticsType.GROUNDED);
     Semantics cf2 = new Semantics(SemanticsType.CF2);
+    CombinedDistance measure = new CombinedDistance();
 
     @BeforeAll
     public void init() {
@@ -44,21 +46,21 @@ public void init() {
         semantics1.add(stage);
         semantics1.add(preferred);
         semantics1.add(grounded);
-        aScenario1 = new AgreementScenario(testFramework9, topic1, semantics1);
+        aScenario1 = new AgreementScenario(testFramework9, topic1, semantics1, measure);
 
         topic2.addAll(topic1);
         topic2.add(d);
         semantics2.addAll(semantics1);
-        aScenario2 = new AgreementScenario(testFramework9, topic2, semantics2);
+        aScenario2 = new AgreementScenario(testFramework9, topic2, semantics2, measure);
 
         semantics3.addAll(semantics1);
         semantics3.add(cf2);
-        aScenario3 = new AgreementScenario(testFramework9, topic2, semantics3);
+        aScenario3 = new AgreementScenario(testFramework9, topic2, semantics3, measure);
 
         testFramework10.addAll(testFramework9);
         testFramework10.addAllAttacks(testFramework9.getAttacks());
         testFramework10.add(f);
-        aScenario4 = new AgreementScenario(testFramework10, topic1, semantics1);
+        aScenario4 = new AgreementScenario(testFramework10, topic1, semantics1, measure);
     }
 
     @Test

diff --git a/src/test/java/diarg/UtilsTest.java b/src/test/java/diarg/UtilsTest.java
@@ -22,29 +22,6 @@ public class UtilsTest {
     Argument e = new Argument("e");
     Argument f = new Argument("f");
 
-    @Test
-    public void determineSetSimilarity() {
-        Collection<Argument> baseSet = new Extension();
-        baseSet.add(a);
-        baseSet.add(b);
-        baseSet.add(c);
-        Collection<Argument> set1 = new Extension();
-        set1.add(d);
-        Collection<Argument> set2 = new Extension();
-        set2.add(b);
-        set2.add(c);
-        set2.add(d);
-        Collection<Argument> set3 = new Extension();
-        set3.addAll(baseSet);
-        set3.add(d);
-        double distance12Is = Utils.determineSetSimilarity(set1, set2, baseSet);
-        double distance13Is = Utils.determineSetSimilarity(set1, set3, baseSet);
-        double distance23Is = Utils.determineSetSimilarity(set2, set3, baseSet);
-        assertEquals(1/3d, distance12Is);
-        assertEquals(0, distance13Is);
-        assertEquals(2/3d, distance23Is);
-    }
-
     @Test
     void determineSubsetMaxMonotonicExtensions() {
         Extension extension1 = new Extension();