README.md

go-subjectivelogic

This Go library implements a number of Subjective Logic operators. Subjective Logic is a type of probabilistic logic that uses subjective opinions instead of probabilities. To learn more about Subjective Logic please refer to "Subjective Logic, A Formalism for Reasoning under Uncertainty" book by Audun Jøsang.

Table of Contents

• Usage
  • Opinion
  • Addition
  • Complement
  • Binomial Multiplication
  • Binomial Comultiplication
  • Belief Constraint Fusion
  • Cumulative Fusion
  • Averaging Fusion
  • Weighted Fusion
  • Trust Discounting
  • Multi-Edge Trust Discounting
  • Opposite-Belief Trust Discounting
• Contributing
• License
• Contact

Usage

Opinion

Subjective Logic is a type of probabilistic logic that uses subjective opinions instead of probabilities. A binomial opinion about the truth of the proposition $x$ is ${\omega }_x=(b_x,d_x,u_x,a_x)$, where:

• $b_x$: belief mass in support of the proposition $x$ being true.
• $d_x$: disbelief mass in support of the proposition $x$ being false.
• $u_x$: uncertainty mass representing lack of evidence.
• $a_x$: base rate i.e. the prior probability of $x$ being true without any evidence.

type Opinion struct {
	belief      float64
	disbelief   float64
	uncertainty float64
	baseRate    float64
}

The following methods have been implemented for the opinion:

• NewOpinion()
• GetBelief()
• GetDisbelief()
• GetUncertainty()
• GetBaseRate()
• Modify()
• ProjProb()
• Compare()
• ToString
• ToStringE()

NewOpinion() method

The NewOpinion() method takes in four float64 values and outputs an Opinion as well as an Error. In case a valid Opinion can be formed, it will be returned and the error will be nil. If the input values violate the requirements for a valid Opinion, the Opinion would be initialized with zeroes and an error will be returned. For a valid Opinion, each input value $i$ must fulfill $0\le i\le 1$ and the following statement $b+d+u=1$ must hold.

opinion, err := subjectivelogic.NewOpinion(.5, .25, .25, .5)

if err != nil {
	println(err.Error())
} else {
	belief := opinion.GetBelief()
	disbelief := opinion.GetDisbelief()
	uncertainty := opinion.GetUncertainty()
	baseRate := opinion.GetBaseRate()
	
	println(fmt.Sprintf("Opinion: %.2f, %.2f, %.2f, %.2f", belief, disbelief, uncertainty, baseRate))
}

This code generates the following output:

Opinion: 0.50, 0.25, 0.25, 0.50

---

Addition

This implements the Addition Operator as defined in Subjective Logic:

$${\omega }_{(x\cup y)}=\{\begin{array}{l}{b}_{x\cup y}=b_x+b_y\\ d_{x\cup y}=\frac{a_x(d_x-b_y)+a_y(d_y-b_x)}{a_x+a_y}\\ u_{x\cup y}=\frac{a_x{u}_x+a_y{u}_y}{a_x+a_y}\\ a_{x\cup y}=0\end{array}$$

API Reference

func Addition(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

Inputs ${\omega }_x=(b_x,d_x,u_x,a_x)$ and ${\omega }_y=(b_y,d_y,u_y,a_y)$ are problematic and will result in an error, if:

$$\begin{array}{rl}{b}_x+b_y& >1\text{, or}\\ a_x+a_y& >1\end{array}$$

Moreover, the Addition Operator will attempt to divide through $0$, if $a_x=a_y=0$, hence this is not allowed and an error will be returned.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5)
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5) 
	opinion3, _ := subjectivelogic.NewOpinion(1, 0, 0, 0.5) 
	
	out1, err1 := subjectivelogic.Addition(&opinion1, &opinion2) //Case 1 
	out2, err2 := subjectivelogic.Addition(&opinion1, &opinion3) //Case 2 
	
	fmt.Println("Case 1:", "Opinion = ", out1.ToString(), "Error:", err1) 
	fmt.Println("Case 2:", "Opinion = ", out2.ToString(), "Error:", err2) 

}

The above code snippet shows the usage of the Addition operator. Case 1 uses two Opinions that are not problematic for the Addition operator, resulting in a valid output Opinion and no error:

Case 1: Opinion =  0.6000000000000001, 0.1, 0.3, 1 Error: <nil>

Case 2 uses two valid Opinions that are problematic for the Addition operator as the sum of their belief masses exceeds $1$. This results in the Addition operator returning a zeroed Opinion and an error.

Case 2: Opinion =  0, 0, 0, 0 Error: Addition: Check the validity of your input values

---

Complement

This implements the Complement Operator as defined in Subjective Logic:

$${\omega }_{\bar{x}}:\{\begin{array}{l}{b}_{\bar{x}}=d_x\\ d_{\bar{x}}=b_x\\ u_{\bar{x}}=u_x\\ a_{\bar{x}}=1-a_x\end{array}$$

API Reference

func Complement(opinion *Opinion) (Opinion, error)

Problematic Inputs

There are no problematic inputs for this operator, as long as they are valid opinions.

Example

func main() {

	opinion, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	
	out, err := subjectivelogic.Complement(&opinion) 

	if err != nil { 
		fmt.Println("Error:", err) 
	} else { 
		fmt.Println("Output:", out, err) 
	}
}

The code snippet above shows the usage of the Complement operator. This specific example will result in the following output:

Output: {0.8 0.2 0 0.5} <nil>

---

Binomial Multiplication

This implements the Binomial Multiplication Operator as defined in Subjective Logic:

$${\omega }_{x\wedge y}:\{\begin{array}{l}{b}_{x\wedge y}=b_x{b}_y+\frac{(1-a_x)a_y{b}_x{u}_y+a_x(1-a_y)b_y{u}_x}{1-a_x{a}_y}\\ d_{x\wedge y}=d_x+d_y-d_x{d}_y\\ u_{x\wedge y}=u_x{u}_y+\frac{(1-a_y)b_x{u}_y+(1-a_x)u_x{b}_y}{1-a_x{a}_y}\\ a_{x\wedge y}=a_x{a}_y\end{array}$$

API Reference

func Multiplication(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

The Binomial Multiplication Operator will try to divide through $0$, if $a_x=a_y=1$, hence this is not allowed and an error is returned.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5)
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5) 

	out, err := subjectivelogic.Multiplication(&opinion1, &opinion2)

	if err != nil { 
		fmt.PrintlnImplementation("Error:", err)
	} else {
		fmt.Println("Output:", out, err) 
	}	
}

The code snippet above shows the usage of the Multiplication operator. This specific example will result in the following output:

Output: {0.12000000000000002 0.8 0.08 0.25} <nil>

---

Binomial Comultiplication

This implements the Comultiplication Operator as defined in Subjective Logic:

$${\omega }_{x\wedge y}:\{\begin{array}{l}{b}_{x\wedge y}=b_x+b_y-b_x{b}_y\\ d_{x\wedge y}=d_x{d}_y+\frac{a_x(1-a_y)d_x{u}_y+(1-a_x)a_y{u}_x{d}_y}{a_x+a_y-a_x{a}_y}\\ u_{x\wedge y}=u_x{u}_y+\frac{a_y{d}_x{u}_y+a_x{u}_x{d}_y}{a_x+a_y-a_x{a}_y}\\ a_{x\wedge y}=a_x+a_y-a_x{a}_y\end{array}$$

API Reference

func Comultiplication(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

The Binomial Comultiplication Operator will try to divide through $0$, if $a_x=a_y=0$, hence this is not allowed and an error will be returned.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5)
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5)

	out, err := subjectivelogic.Comultiplication(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Comultiplication operator. This specific example will result in the following output:

Output: {0.52 0.16 0.32 0.75} <nil>

---

Belief Constraint Fusion

==This implements the Belief Constraint Fusion Operator as defined in Subjective Logic:==

NEEDS TO BE EDITED

$${\omega }_X^{(A\mathrm{\&}B)}:\{\begin{array}{l}{b}_X^{(A\mathrm{\&}B)}=\frac{b_X^A{u}_X^B+b_X^B{u}_X^A+b_X^A{b}_X^B}{1-Con}\\ d_X^{(A\mathrm{\&}B)}=\frac{d_X^A{u}_X^B+d_X^B{u}_X^A+d_X^A{d}_X^B}{1-Con}\\ u_X^{(A\mathrm{\&}B)}=\frac{u_X^A{u}_X^B}{1-Con}\\ a_X^{(A\mathrm{\&}B)}=\frac{a_X^A(1-u_X^A)+a_X^B(1-u_X^B)}{2-u_X^A-u_X^B}& \text{for}{u}_X^A+u_X^B<2\\ a_X^{(A\mathrm{\&}B)}=\frac{a_X^A+a_X^B}{2}& \text{for}{u}_X^A=u_X^B=1\end{array}$$ $$Con=b_X^A{d}_X^B+d_X^A{b}_X^B$$

API Reference

func ConstraintFusion(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

The Belief Constraint Fusion Operator will try to divide through $0$, if the conflict variable $Con=1$, and an error will be returned.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5)

	out, err := subjectivelogic.ConstraintFusion(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Belief Constraint operator. This specific example will result in the following output:

Output: {0.2941176470588236 0.7058823529411764 0 0.5} <nil>

---

Cumulative Fusion

This implements the Aleatory Cumulative Fusion Operator as defined in Subjective Logic:

Case I: For $u_X^A\ne 0\vee u_X^B\ne 0$:

$${\omega }_X^{(A\diamond B)}:\{\begin{array}{l}{b}_X^{(A\diamond B)}(x)=\frac{b_X^A(x)u_X^B+b_X^B(x)u_X^A}{u_X^A+u_X^B-u_X^A{u}_X^B}\\ u_X^{(A\diamond B)}=\frac{u_X^A{u}_X^B}{u_X^A+u_X^B-u_X^A{u}_X^B}\\ a_X^{(A\diamond B)}(x)=\frac{a_X^A(x)u_X^B+a_X^B(x)u_X^A-(a_X^A(x)+a_X^B(x))u_X^B{u}_X^A}{u_X^A+u_X^B-2u_X^A{u}_X^B}& \text{if}{u}_X^A\ne 1\vee u_X^B\ne 1\\ a_X^{(A\diamond B)}(x)=\frac{a_X^A(x)+a_X^B(x)}{2}& \text{if}{u}_X^A=u_X^B=1\end{array}$$

Case II: For $u_X^A=u_X^B=0$:

$${\omega }_X^{(A\diamond B)}:\{\begin{array}{l}{b}_X^{(A\diamond B)}(x)={\gamma }_X^A{b}_X^A(x)+{\gamma }_X^B{b}_X^B(x)\\ u_X^{(A\diamond B)}=0\\ a_X^{(A\diamond B)}(x)={\gamma }_X^A{a}_X^A(x)+{\gamma }_X^B{a}_X^B(x)\end{array}$$ $$\text{where}{\gamma }_X^A={\gamma }_X^B=0.5$$

API Reference

func CumulativeFusion(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

There are no problematic inputs for this operator, as long as they are valid opinions.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5)

	out, err := subjectivelogic.CumulativeFusion(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Cumulative fusion operator. This specific example will result in the following output:

Output: {0.2 0.8 0 0.5} <nil>

---

Averaging Fusion

This implements the Averaging Fusion Operator as defined in Subjective Logic:

Case I: For $u_X^A\ne 0\vee u_X^B\ne 0$:

$${\omega }_X^{(A\underset{―}{\diamond }B)}:\{\begin{array}{l}{b}_X^{(A\underset{―}{\diamond }B)}(x)=\frac{b_X^A(x)u_X^B+b_X^B(x)u_X^A}{u_X^A+u_X^B}\\ u_X^{(A\underset{―}{\diamond }B)}=\frac{2u_X^A{u}_X^B}{u_X^A+u_X^B}\\ a_X^{(A\underset{―}{\diamond }B)}(x)=\frac{a_X^A(x)+a_X^B(x)}{2}\end{array}$$

Case II: For $u_X^A=u_X^B=0$:

$${\omega }_X^{(A\underset{―}{\diamond }B)}:\{\begin{array}{l}{b}_X^{(A\underset{―}{\diamond }B)}(x)={\gamma }_X^A{b}_X^A(x)+{\gamma }_X^B{b}_X^B(x)\\ u_X^{(A\underset{―}{\diamond }B)}=0\\ a_X^{(A\underset{―}{\diamond }B)}(x)={\gamma }_X^A{a}_X^A(x)+{\gamma }_X^B{a}_X^B(x)\end{array}$$ $$\text{where}{\gamma }_X^A={\gamma }_X^B=0.5$$

API Reference

func AveragingFusion(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

There are no problematic inputs for this operator, as long as they are valid opinions.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5)

	out, err := subjectivelogic.AveragingFusion(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Averaging fusion operator. This specific example will result in the following output:

Output: {0.2 0.8 0 0.5} <nil>

---

Weighted Fusion

This implements the Weighted Fusion Operator as defined in Subjective Logic:

Case I: For $(u_X^A\ne 0\vee u_X^B\ne 0)\wedge (u_X^A\ne 1\vee u_X^B\ne 1)$:

$${\omega }_X^{(A\diamond B)}:\{\begin{array}{l}{b}_X^{(A\diamond B)}(x)=\frac{b_X^A(x)(1-u_X^A)u_X^B+b_X^B(x)(1-u_X^B)u_X^A}{u_X^A+u_X^B-2u_X^A{u}_X^B}\\ u_X^{(A\diamond B)}=\frac{(2-u_X^A-u_X^B)u_X^A{u}_X^B}{u_X^A+u_X^B-2u_X^A{u}_X^B}\\ a_X^{(A\diamond B)}(x)=\frac{a_X^A(x)(1-u_X^A)+a_X^B(x)(1-u_X^B)}{2-u_X^A-u_X^B}\end{array}$$

Case II: For $u_X^A=u_X^B=0$:

$${\omega }_X^{(A\diamond B)}:\{\begin{array}{l}{b}_X^{(A\diamond B)}(x)={\gamma }_X^A{b}_X^A(x)+{\gamma }_X^B{b}_X^B(x)\\ u_X^{(A\diamond B)}=0\\ a_X^{(A\diamond B)}(x)={\gamma }_X^A{a}_X^A(x)+{\gamma }_X^B{a}_X^B(x)\end{array}$$ $$\text{where}{\gamma }_X^A={\gamma }_X^B=0.5$$

Case III: $u_X^A=u_X^B=1$:

$${\omega }_X^{(A\diamond B)}:\{\begin{array}{l}{b}_X^{(A\diamond B)}(x)=0\\ u_X^{(A\diamond B)}=1\\ a_X^{(A\diamond B)}(x)=\frac{a_X^A(x)+a_X^B(x)}{2}\end{array}$$

API Reference

func WeightedFusion(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

There are no problematic inputs for this operator, as long as they are valid opinions.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5)

	out, err := subjectivelogic.WeightedFusion(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Weighted fusion operator. This specific example will result in the following output:

Output: {0.2 0.8 0 0.5} <nil>

---

Trust Discounting

This implements the Trust Discounting Operator as defined in Subjective Logic:

$${\omega }_X^{[A;B]}:\{\begin{array}{ll}{\mathit{b}}_X^{[A;B]}(x)& ={\mathit{P}}_B^A\ast {\mathit{b}}_X^B(x)\\ u_X^{[A;B]}& =1-{\mathit{P}}_B^A\ast \sum _{x\in \mathcal{R}(\mathbb{X})}{\mathit{b}}_X^B(x)\\ {\mathit{a}}_X^{[A;B]}(x)& ={\mathit{a}}_X^B(x)\\ \end{array}$$

API Reference

func TrustDiscounting(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

There are no problematic inputs for this operator, as long as they are valid opinions.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	opinion2, _ := subjectivelogic.NewOpinion(0.4, 0, 0.6, 0.5)

	out, err := subjectivelogic.TrustDiscounting(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Trust discounting operator. This specific example will result in the following output:

Output: {0.08000000000000002 0 0.9199999999999999 0.5} <nil>

Trust Discounting for Multi-edge Path

This implements the Trust Discounting Operator for Multi-edge Paths as defined in Subjective Logic.

If $[A_1,...,A_n]$ denotes the referral trust path and $[A_n,X]$ the functional trust, the Trust Discounting Operator for multi-edge paths is defined as:

$${\omega }_X^{A_1}:\{\begin{array}{ll}{b}_X^{A_1}(x)& =P_{A_n}^{A_1}\ast b_X^{A_n}(x)\\ u_X^{A_1}& =1-P_{A_n}^{A_1}\ast \sum _{x\in X}{b}_X^{A_n}(x)\\ a_X^{A_1}(x)& =a_X^{A_n}(x)\end{array}$$

and:

$$P_{A_n}^{A_1}=\prod _{i=1}^{n-1}{P}_{A_{i+1}}^{A_i}$$

API Reference

TBD

Problematic Inputs

TBD

Example

TBD

Opposite-Belief Trust Discounting

This implements the Opposite-Belief Trust Discounting Operator as defined in Subjective Logic:

$${\omega }_X^{[A;B]}:\{\begin{array}{ll}{b}_X^{[A;B]}& =b_B^A{b}_X^B+d_B^A{d}_X^B\\ d_X^{[A;B]}& =b_B^A{d}_X^B+d_B^A{b}_X^B\\ u_X^{[A;B]}& =u_B^A+(b_B^A+d_B^A)u_X^B\\ a_X^{[A;B]}& =a_X^B\\ \end{array}$$

API Reference

func TrustDiscountingOB(opinion1 *Opinion, opinion2 *Opinion) (Opinion, error)

Problematic Inputs

There are no problematic inputs for this operator, as long as they are valid opinions.

Example

func main() {

	opinion1, _ := subjectivelogic.NewOpinion(0.2, 0.8, 0, 0.5) 
	opinion2, _ := subjectivelogic.NewOpinion(1, 0, 0, 0.5)

	out, err := subjectivelogic.TrustDiscountingOB(&opinion1, &opinion2)

	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Output:", out, err)
	}
}

The code snippet above shows the usage of the Trust discounting operator. This specific example will result in the following output:

Output: {0.2 0.8 0 0.5} <nil>

Contributing

Contributions are very welcome! Please let us know if you find an issue and have ideas for improvement. Alternately, open an issue or submit a pull request on GitHub.

License

This project is licensed under the Apache License, Verion 2.0 - see the LICENSE file for details.

Contact

In case of problems or issues, please open an issue on GitHub.