Merge pull request #102 from aclai-lab/minor-edit-to-manyvalued-module

Minor edit to many-expert-algebras related code

Author: alberto-paparella

src/many-valued-logics/check.jl

@@ -222,6 +222,16 @@ function SoleLogics.collatetruth(
     ntuple(i -> SoleLogics.collatetruth(→, (x[i], y[i]), a.experts[i]), M)
 end
 
+function SoleLogics.check(
+    φ::SyntaxTree,
+    i::Interpretation,
+    a::ManyExpertAlgebra, 
+    args...; 
+    kwargs...)
+
+    interpret(φ, i, a, args...; kwargs...)
+end
+
 """
     alphacheck(
         α::FiniteTruth,

src/many-valued-logics/fuzzylogics.jl

@@ -13,8 +13,16 @@ struct FuzzyLogic{T} <: AbstractAlgebra{ContinuousTruth}
 end
 
 function Base.show(io::IO, a::FuzzyLogic)
-    println(string(typeof(a)))
-    println("t-norm: " * string(a.tnorm.func))
+    tnorm_name = if a.tnorm === GodelTNorm
+        "Gödel (min)"
+    elseif a.tnorm === LukasiewiczTNorm
+        "Łukasiewicz"
+    elseif a.tnorm === ProductTNorm
+        "Product (*)"
+    else
+        string(a.tnorm.func)
+    end
+    print(io, "FuzzyLogic(t-norm: ", tnorm_name, ")")
 end
 
 iscrisp(::FuzzyLogic) = false

src/many-valued-logics/many-expert-algebras.jl

@@ -2,7 +2,7 @@ import ..SoleLogics: AbstractAlgebra, top, bot, iscrisp
 using StaticArrays
 
 """
-    struct ManyExpertAlgebra{N, A <: SVector{N, FuzzyLogic}} <: AbstractAlgebra{ContinuousTruth}
+    struct ManyExpertAlgebra <: AbstractAlgebra{ContinuousTruth}
         experts::A    
     end
 A Many Expert Algebra is a combination of N continuous fuzzy logics, each potentially
@@ -21,8 +21,12 @@ struct ManyExpertAlgebra <: AbstractAlgebra{ContinuousTruth}
 end
 
 function Base.show(io::IO, a::ManyExpertAlgebra)
-    println(typeof(a))
-    for expert in a.experts print(expert) end
+    n = length(a.experts)
+    print(io, "ManyExpertAlgebra with ", n, " expert", n == 1 ? "" : "s", ":")
+    for (i, expert) in enumerate(a.experts)
+        print(io, "\n  [", i, "] ")
+        show(io, expert)
+    end
 end
 
 function addexperts!(a::ManyExpertAlgebra, experts::FuzzyLogic...)

src/many-valued-logics/order-utilities.jl

@@ -47,7 +47,8 @@ end
         T1<:Truth,
         T2<:Truth
     }
-Return true if `t1` < `t2` in fuzzy logic `l`. For continuous truth values, 
+
+Return true if `t1` ≤ `t2` in fuzzy logic `l`. For continuous truth values, 
 this is the standard strict less-than ordering on real numbers in [0,1].
 
 See also [`precedes`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
@@ -65,6 +66,37 @@ See also [`precedes`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
     return t1.value <= t2.value ? true : false
 end
 
+"""
+    function precedeq(
+        l::ManyExpertAlgebra,
+        t1::NTuple{N, T1},
+        t2::NTuple{N, T2}
+    ) where {
+        T1 <: Truth,
+        T2 <: Truth,
+        N
+    }
+
+Return true if each truth in the tuple `t1` ≤ `t2` in a many expert algebra. For continuous 
+truth values, this is the standard strict less-than ordering on real numbers in [0,1].
+
+See also [`precedes`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
+"""
+function precedeq(
+    l::ManyExpertAlgebra,
+    t1::NTuple{N, T1},
+    t2::NTuple{N, T2}
+) where {
+    T1 <: Truth,
+    T2 <: Truth,
+    N
+}
+    for i in 1:N
+        if !precedeq(l.experts[i], t1[i], t2[i]) return false end
+    end
+    return true
+end
+
 """
     function precedes(
         l::L,
@@ -127,6 +159,38 @@ See also [`precedeq`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
     return t1.value < t2.value ? true : false
 end
 
+"""
+    function precedes(
+        l::ManyExpertAlgebra,
+        t1::NTuple{N, T1},
+        t2::NTuple{N, T2}
+    ) where {
+        T1 <: Truth,
+        T2 <: Truth,
+        N
+    }
+
+Return true if each truth in the tuple `t1` < `t2` in a many expert algebra. For continuous 
+truth values, this is the standard strict less-than ordering on real numbers in [0,1].
+
+See also [`precedes`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
+"""
+
+function precedes(
+    l::ManyExpertAlgebra,
+    t1::NTuple{N, T1},
+    t2::NTuple{N, T2}
+) where {
+    T1 <: Truth,
+    T2 <: Truth,
+    N
+}
+    for i in 1:N
+        if !precedes(l.experts[i], t1[i], t2[i]) return false end
+    end
+    return true
+end
+
 """
     function succeedeq(
         l::L,
@@ -189,6 +253,38 @@ See also [`precedes`](@ref), [`precedeq`](@ref), [`succeedes`](@ref).
     return t1.value >= t2.value ? true : false
 end
 
+"""
+    function succedeq(
+        l::ManyExpertAlgebra,
+        t1::NTuple{N, T1},
+        t2::NTuple{N, T2}
+    ) where {
+        T1 <: Truth,
+        T2 <: Truth,
+        N
+    }
+
+Return true if each truth in the tuple `t1` ≥ `t2` in a many expert algebra. For continuous 
+truth values, this is the standard strict less-than ordering on real numbers in [0,1].
+
+See also [`precedes`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
+"""
+
+function succeedeq(
+    l::ManyExpertAlgebra,
+    t1::NTuple{N, T1},
+    t2::NTuple{N, T2}
+) where {
+    T1 <: Truth,
+    T2 <: Truth,
+    N
+}
+    for i in 1:N
+        if !succeedeq(l.experts[i], t1[i], t2[i]) return false end
+    end
+    return true
+end
+
 """
     function succeedes(
         l::L,
@@ -251,6 +347,38 @@ See also [`precedes`](@ref), [`precedeq`](@ref), [`succeedeq`](@ref).
     return t1.value > t2.value ? true : false
 end
 
+"""
+    function succedes(
+        l::ManyExpertAlgebra,
+        t1::NTuple{N, T1},
+        t2::NTuple{N, T2}
+    ) where {
+        T1 <: Truth,
+        T2 <: Truth,
+        N
+    }
+
+Return true if each truth in the tuple `t1` > `t2` in a many expert algebra. For continuous 
+truth values, this is the standard strict less-than ordering on real numbers in [0,1].
+
+See also [`precedes`](@ref), [`succeedes`](@ref), [`succeedeq`](@ref).
+"""
+
+function succeedes(
+    l::ManyExpertAlgebra,
+    t1::NTuple{N, T1},
+    t2::NTuple{N, T2}
+) where {
+    T1 <: Truth,
+    T2 <: Truth,
+    N
+}
+    for i in 1:N
+        if !succeedes(l.experts[i], t1[i], t2[i]) return false end
+    end
+    return true
+end
+
 """
     function lesservalues(
         l::L,

test/many-valued-logics.jl

@@ -164,11 +164,22 @@ FuzzyLogic(GodelTNorm)
 MXA = ManyExpertAlgebra(GodelLogic)
 addexperts!(MXA, LukasiewiczLogic, ProductLogic)
 
+@test occursin("Gödel", sprint(show, MXA))
+@test occursin("Łukasiewicz", sprint(show, MXA))
+@test occursin("Product", sprint(show, MXA))
+
+@test occursin("+", sprint(show, FuzzyLogic(ContinuousBinaryOperation(+))))
+
 @test iscrisp(MXA) == false
 
 @test top(MXA) == ntuple(i -> top(MXA.experts[i]), 3)
 @test bot(MXA) == ntuple(i -> bot(MXA.experts[i]), 3)
 
+@test precedeq(MXA, (ContinuousTruth(0.0), ContinuousTruth(0.0), ContinuousTruth(0.5)), (ContinuousTruth(0.0), ContinuousTruth(0.0), ContinuousTruth(0.5)))
+@test precedes(MXA, (ContinuousTruth(0.0), ContinuousTruth(0.0), ContinuousTruth(0.5)), (ContinuousTruth(1.0), ContinuousTruth(1.0), ContinuousTruth(0.7)))
+@test succeedeq(MXA, (ContinuousTruth(0.0), ContinuousTruth(0.0), ContinuousTruth(0.5)), (ContinuousTruth(0.0), ContinuousTruth(0.0), ContinuousTruth(0.5)))
+@test succeedes(MXA, (ContinuousTruth(1.0), ContinuousTruth(1.0), ContinuousTruth(0.7)), (ContinuousTruth(0.0), ContinuousTruth(0.0), ContinuousTruth(0.5)))
+
 
 ################################################################################
 #### Nine-valued algebra (Heyting case) ########################################
@@ -274,15 +285,15 @@ z = Atom("z")
 ################################################################################
 
 @test interpret(parseformula("v∧w"), TruthDict([v => ⊤, w => ⊤]), MXA) == top(MXA)
-@test interpret(parseformula("v∨w"), TruthDict([v => ⊥, w => ⊥]), MXA) == bot(MXA)
-@test interpret(parseformula("v∧w"), TruthDict([v => ⊥, w => ⊤]), MXA) == bot(MXA)
+@test check(parseformula("v∨w"), TruthDict([v => ⊥, w => ⊥]), MXA) == bot(MXA)
+@test check(parseformula("v∧w"), TruthDict([v => ⊥, w => ⊤]), MXA) == bot(MXA)
 @test interpret(parseformula("v∨w"), TruthDict([v => ⊤, w => ⊥]), MXA) == top(MXA)
 @test top(MXA) == interpret(parseformula("v∨w"), TruthDict([v => ContinuousTruth(0), w => ⊤]), MXA)
 @test bot(MXA) == interpret(parseformula("(v∧w∧x)∨(y∧z)"), TruthDict([v => ⊥, w => ContinuousTruth(0.5), x => ContinuousTruth(0.0), y => ⊥, z => ContinuousTruth(0.4)]), MXA)
 @test top(MXA) == interpret(parseformula("v→w"), TruthDict([v => ⊥, w => ⊤]), MXA)
-@test interpret(parseformula("(v→w)∧(w→v)"), TruthDict([v => ContinuousTruth(0.3), w => ContinuousTruth(0.6)]), MXA) == (ContinuousTruth(0.3), ContinuousTruth(0.7), ContinuousTruth(0.5))
+@test check(parseformula("(v→w)∧(w→v)"), TruthDict([v => ContinuousTruth(0.3), w => ContinuousTruth(0.6)]), MXA) == (ContinuousTruth(0.3), ContinuousTruth(0.7), ContinuousTruth(0.5))
 @test interpret(parseformula("((v→w)∨(w→x))∧(v∨x)"), TruthDict([v => ContinuousTruth(0.7), w => ContinuousTruth(0.2), x => ContinuousTruth(0.5)]), MXA) == (ContinuousTruth(0.7), ContinuousTruth(0.7), ContinuousTruth(0.7))
-@test interpret(parseformula("(v∧(w∨x))→(y∨z)"), TruthDict([v => ContinuousTruth(0.6), w => ContinuousTruth(0.4), x => ContinuousTruth(0.9), y => ContinuousTruth(0.3), z => ContinuousTruth(0.8)]), MXA) == (ContinuousTruth(1.0), ContinuousTruth(1.0), ContinuousTruth(1.0))
+@test check(parseformula("(v∧(w∨x))→(y∨z)"), TruthDict([v => ContinuousTruth(0.6), w => ContinuousTruth(0.4), x => ContinuousTruth(0.9), y => ContinuousTruth(0.3), z => ContinuousTruth(0.8)]), MXA) == (ContinuousTruth(1.0), ContinuousTruth(1.0), ContinuousTruth(1.0))
 
 ################################################################################
 #### Finite FLew-chains generation #############################################