Support of message passing for Boolean functions

src/ReactiveMP.jl

@@ -128,11 +128,15 @@ include("nodes/bifm_helper.jl")
 include("nodes/probit.jl")
 include("nodes/flow/flow.jl")
 include("nodes/poisson.jl")
+include("nodes/or.jl")
+include("nodes/not.jl")
 
 # Deterministic nodes
 include("nodes/addition.jl")
 include("nodes/subtraction.jl")
 include("nodes/multiplication.jl")
+include("nodes/and.jl")
+include("nodes/implication.jl")
 
 include("rules/prototypes.jl")
 

src/nodes/and.jl

@@ -0,0 +1,5 @@
+export AND
+
+struct AND end
+
+@node AND Deterministic [out, in1, in2]

src/nodes/implication.jl

@@ -0,0 +1,5 @@
+export IMPL
+
+struct IMPL end
+
+@node IMPL Deterministic [out, in1, in2]

src/nodes/not.jl

@@ -0,0 +1,5 @@
+export NOT
+
+struct NOT end
+
+@node NOT Deterministic [out, in1]

src/nodes/or.jl

@@ -0,0 +1,5 @@
+export OR
+
+struct OR end
+
+@node OR Deterministic [out, in1, in2]

src/rules/and/in1.jl

@@ -0,0 +1,8 @@
+@rule AND(:in1, Marginalisation) (
+    m_out::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pout, pin2 = mean(m_out), mean(m_in2)
+
+    return Bernoulli((1 - pout - pin2 + 2 * pout * pin2) / (2 - 2 * pout - pin2 + 2 * pout * pin2))
+end

src/rules/and/in2.jl

@@ -0,0 +1,3 @@
+@rule AND(:in2, Marginalisation) (m_out::Bernoulli, m_in1::Bernoulli, meta::Any) = begin
+    return @call_rule AND(:in1, Marginalisation) (m_out = m_out, m_in2 = m_in1, meta = meta)
+end

src/rules/and/marginals.jl

@@ -0,0 +1,8 @@
+@marginalrule AND(:in1_in2) (
+    m_out::Bernoulli,
+    m_in1::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin1, pin2, pout = mean(m_in1), mean(m_in2), mean(m_out)
+    return Contingency([(1-pin1)*(1-pin2)*(1-pout) (1-pin1)*pin2*(1-pout); pin1*(1-pin2)*(1-pout) pin1*pin2*pout])
+end

src/rules/and/out.jl

@@ -0,0 +1,8 @@
+@rule AND(:out, Marginalisation) (
+    m_in1::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin1, pin2 = mean(m_in1), mean(m_in2)
+
+    return Bernoulli(pin1 * pin2)
+end

src/rules/implication/in1.jl

@@ -0,0 +1,8 @@
+@rule typeof(IMPL)(:in1, Marginalisation) (
+    m_out::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pout, pin2 = mean(m_out), mean(m_in2)
+
+    return Bernoulli((1 - pout - pin2 + 2 * pout * pin2) / (1 - pin2 + 2 * pout * pin2))
+end

src/rules/implication/in2.jl

@@ -0,0 +1,8 @@
+@rule typeof(IMPL)(:in2, Marginalisation) (
+    m_out::Bernoulli,
+    m_in1::Bernoulli
+) = begin
+    pout, pin1 = mean(m_out), mean(m_in1)
+
+    return Bernoulli((pout) / (2 * pout + pin1 - 2 * pout * pin1))
+end

src/rules/implication/marginals.jl

@@ -0,0 +1,8 @@
+@marginalrule IMPL(:in1_in2) (
+    m_out::Bernoulli,
+    m_in1::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin1, pin2, pout = mean(m_in1), mean(m_in2), mean(m_out)
+    return Contingency([(1-pin1)*pout*(1-pin2) (1-pin1)*pin2*pout; pin1*(1-pin2)*(1-pout) pin1*pin2*pout])
+end

src/rules/implication/out.jl

@@ -0,0 +1,8 @@
+@rule typeof(IMPL)(:out, Marginalisation) (
+    m_in1::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin1, pin2 = mean(m_in1), mean(m_in2)
+
+    return Bernoulli(1 - pin1 + pin1 * pin2)
+end

src/rules/not/in1.jl

@@ -0,0 +1,3 @@
+export rule
+
+@rule NOT(:in1, Marginalisation) (m_out::Bernoulli,) = Bernoulli(1 - mean(m_out))

src/rules/not/marginals.jl

@@ -0,0 +1,7 @@
+@marginalrule NOT(:in1) (
+    m_out::Bernoulli,
+    m_in1::Bernoulli
+) = begin
+    pin, pout = mean(m_in1), mean(m_out)
+    return Bernoulli(pin * (1 - pout) / (pin * (1 - pout) + pout * (1 - pin)))
+end

src/rules/not/out.jl

@@ -0,0 +1,3 @@
+export rule
+
+@rule NOT(:out, Marginalisation) (m_in1::Bernoulli,) = Bernoulli(1 - mean(m_in1))

src/rules/or/in1.jl

@@ -0,0 +1,7 @@
+@rule OR(:in1, Marginalisation) (
+    m_out::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin2, pout = mean(m_in2), mean(m_out)
+    return Bernoulli(pout / (1 - pin2 + 2 * pin2 * pout))
+end

src/rules/or/in2.jl

@@ -0,0 +1,3 @@
+@rule OR(:in2, Marginalisation) (m_out::Bernoulli, m_in1::Bernoulli) = begin
+    return @call_rule typeof(OR)(:in1, Marginalisation) (m_out = m_out, m_in2 = m_in1, meta = meta)
+end

src/rules/or/marginals.jl

@@ -0,0 +1,8 @@
+@marginalrule OR(:in1_in2) (
+    m_out::Bernoulli,
+    m_in1::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin1, pin2, pout = mean(m_in1), mean(m_in2), mean(m_out)
+    return Contingency([(1-pin1)*(1-pin2)*(1-pout) (1-pin1)*pin2*pout; pin1*(1-pin2)*pout pin1*pin2*pout])
+end

src/rules/or/out.jl

@@ -0,0 +1,8 @@
+@rule OR(:out, Marginalisation) (
+    m_in1::Bernoulli,
+    m_in2::Bernoulli
+) = begin
+    pin1, pin2 = mean(m_in1), mean(m_in2)
+
+    return Bernoulli(pin1 + pin2 - pin1 * pin2)
+end

src/rules/prototypes.jl

@@ -127,3 +127,22 @@ include("bifm_helper/out.jl")
 include("poisson/l.jl")
 include("poisson/marginals.jl")
 include("poisson/out.jl")
+
+include("or/in1.jl")
+include("or/in2.jl")
+include("or/out.jl")
+include("or/marginals.jl")
+
+include("not/in1.jl")
+include("not/out.jl")
+include("not/marginals.jl")
+
+include("and/in1.jl")
+include("and/in2.jl")
+include("and/out.jl")
+include("and/marginals.jl")
+
+include("implication/in1.jl")
+include("implication/in2.jl")
+include("implication/out.jl")
+include("implication/marginals.jl")

test/nodes/test_and.jl

@@ -0,0 +1,20 @@
+module OrNodeTest
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "AndNode" begin
+    @testset "Creation" begin
+        node = make_node(AND)
+
+        @test functionalform(node) === AND
+        @test sdtype(node) === Deterministic()
+        @test name.(interfaces(node)) === (:out, :in1, :in2)
+        @test factorisation(node) === ((1, 2, 3),)
+        @test localmarginalnames(node) === (:out_in1_in2,)
+        @test metadata(node) === nothing
+    end
+end
+end

test/nodes/test_implication.jl

@@ -0,0 +1,20 @@
+module OrNodeTest
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "ImplicationNode" begin
+    @testset "Creation" begin
+        node = make_node(IMPL)
+
+        @test functionalform(node) === IMPL
+        @test sdtype(node) === Deterministic()
+        @test name.(interfaces(node)) === (:out, :in1, :in2)
+        @test factorisation(node) === ((1, 2, 3),)
+        @test localmarginalnames(node) === (:out_in1_in2,)
+        @test metadata(node) === nothing
+    end
+end
+end

test/nodes/test_not.jl

@@ -0,0 +1,19 @@
+module NotNodeTest
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "NotNode" begin
+    @testset "Creation" begin
+        node = make_node(NOT)
+
+        @test functionalform(node) === NOT
+        @test sdtype(node) === Deterministic()
+        @test name.(interfaces(node)) === (:out, :in)
+        @test factorisation(node) === ((1, 2),)
+        @test metadata(node) === nothing
+    end
+end
+end

test/nodes/test_or.jl

@@ -0,0 +1,20 @@
+module OrNodeTest
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "OrNode" begin
+    @testset "Creation" begin
+        node = make_node(OR)
+
+        @test functionalform(node) === OR
+        @test sdtype(node) === Deterministic()
+        @test name.(interfaces(node)) === (:out, :in1, :in2)
+        @test factorisation(node) === ((1, 2, 3),)
+        @test localmarginalnames(node) === (:out_in1_in2,)
+        @test metadata(node) === nothing
+    end
+end
+end

test/rules/and/test_in1.jl

@@ -0,0 +1,22 @@
+module RulesANDIn1Test
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "rules:AND:in1" begin
+    @testset "Belief Propagation: (m_out::Bernoulli, m_in2::Bernoulli)" begin
+        @test_rules [with_float_conversions = true] AND(:in1, Marginalisation) [
+            (
+                input = (m_out = Bernoulli(0.6), m_in2 = Bernoulli(0.5)),
+                output = Bernoulli(0.5 / 0.9)
+            ),
+            (
+                input = (m_out = Bernoulli(0.3), m_in2 = Bernoulli(0.4)),
+                output = Bernoulli(0.54 / 1.24)
+            )
+        ]
+    end
+end
+end

test/rules/and/test_in2.jl

@@ -0,0 +1,22 @@
+module RulesANDIn2Test
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "rules:AND:in2" begin
+    @testset "Belief Propagation: (m_out::Bernoulli, m_in1::Bernoulli)" begin
+        @test_rules [with_float_conversions = true] AND(:in2, Marginalisation) [
+            (
+                input = (m_out = Bernoulli(0.6), m_in1 = Bernoulli(0.5)),
+                output = Bernoulli(0.5 / 0.9)
+            ),
+            (
+                input = (m_out = Bernoulli(0.3), m_in1 = Bernoulli(0.4)),
+                output = Bernoulli(0.54 / 1.24)
+            )
+        ]
+    end
+end
+end

test/rules/and/test_marginals.jl

@@ -0,0 +1,32 @@
+module RulesANDMarginalsTest
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules, @test_marginalrules
+
+@testset "rules:AND:marginals" begin
+    @testset ":in1_in2 (m_out::Bernoulli, m_in1::Bernoulli, m_in2::Bernoulli)" begin
+        @test_marginalrules [with_float_conversions = false] AND(:in1_in2) [
+            (
+                input = (
+                    m_out = Bernoulli(0.5),
+                    m_in1 = Bernoulli(0.5),
+                    m_in2 = Bernoulli(0.5)
+                ),
+                output = (Contingency([0.5^3 0.5^3; 0.5^3 0.5^3])
+                )
+            ),
+            (
+                input = (
+                    m_out = Bernoulli(0.2),
+                    m_in1 = Bernoulli(0.8),
+                    m_in2 = Bernoulli(0.4)
+                ),
+                output = (Contingency([0.2*0.8*0.6 0.2*0.8*0.4; 0.8*0.8*0.6 0.2*0.8*0.4])
+                )
+            )
+        ]
+    end
+end
+end

test/rules/and/test_out.jl

@@ -0,0 +1,22 @@
+module RulesANDOutTest
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "rules:AND:out" begin
+    @testset "Belief Propagation: (m_in1::Bernoulli, m_in2::Bernoulli)" begin
+        @test_rules [with_float_conversions = true] AND(:out, Marginalisation) [
+            (
+                input = (m_in1 = Bernoulli(0.3), m_in2 = Bernoulli(0.5)),
+                output = Bernoulli(0.15)
+            ),
+            (
+                input = (m_in1 = Bernoulli(0.4), m_in2 = Bernoulli(0.3)),
+                output = Bernoulli(0.12)
+            )
+        ]
+    end
+end
+end

test/rules/implication/test_in1.jl

@@ -0,0 +1,22 @@
+module RulesImplicationIn1Test
+
+using Test
+using ReactiveMP
+using Random
+import ReactiveMP: @test_rules
+
+@testset "rules:IMPL:in1" begin
+    @testset "Belief Propagation: (m_out::Bernoulli, m_in2::Bernoulli)" begin
+        @test_rules [with_float_conversions = true] IMPL(:in1, Marginalisation) [
+            (
+                input = (m_out = Bernoulli(0.6), m_in2 = Bernoulli(0.5)),
+                output = Bernoulli(0.5 / 1.1)
+            ),
+            (
+                input = (m_out = Bernoulli(0.2), m_in2 = Bernoulli(0.5)),
+                output = Bernoulli(0.5 / 0.7)
+            )
+        ]
+    end
+end
+end