compiled-knowledge 4.0.0a5__cp313-cp313-macosx_10_13_universal2.whl

ck/example/rain.py

@@ -0,0 +1,39 @@
+from ck.pgm import PGM
+
+
+class Rain(PGM):
+    """
+    This PGM is the pedagogical 'Rain' Bayesian network.
+    See Adnan Darwiche, 2009, Modeling and Reasoning with Bayesian Networks, p127.
+    """
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        a = self.new_rv('Winter', (True, False))
+        b = self.new_rv('Sprinkler', (True, False))
+        c = self.new_rv('Rain', (True, False))
+        d = self.new_rv('Wet Grass', (True, False))
+        e = self.new_rv('Slippery Road', (True, False))
+
+        f_a = self.new_factor(a).set_cpt()
+        f_ba = self.new_factor(b, a).set_cpt()
+        f_ca = self.new_factor(c, a).set_cpt()
+        f_dbc = self.new_factor(d, b, c).set_cpt()
+        f_ec = self.new_factor(e, c).set_cpt()
+
+        f_a.set_cpd((), (0.6, 0.4))
+
+        f_ba.set_cpd(0, (0.2, 0.8))
+        f_ba.set_cpd(1, (0.75, 0.25))
+
+        f_ca.set_cpd(0, (0.8, 0.2))
+        f_ca.set_cpd(1, (0.1, 0.9))
+
+        f_dbc.set_cpd((0, 0), (0.95, 0.05))
+        f_dbc.set_cpd((0, 1), (0.9, 0.1))
+        f_dbc.set_cpd((1, 0), (0.8, 0.2))
+        f_dbc.set_cpd((1, 1), (0, 1))
+
+        f_ec.set_cpd(0, (0.7, 0.3))
+        f_ec.set_cpd(1, (0, 1))

ck/example/rectangle.py

@@ -0,0 +1,161 @@
+import random as _random
+from typing import Callable
+
+import numpy as _np
+
+from ck.pgm import PGM
+
+
+class Rectangle(PGM):
+    """
+    This PGM is an interpretation of the 'rectangle' Bayesian network as discussed
+    in "An Advance on Variable Elimination with Applications to Tensor-Based Computation",
+    Adnan Darwiche, ECAI-2020.
+    """
+
+    def __init__(
+            self,
+            n: int = 8,
+            duplicate_functions: int = 1,
+            extend_label: bool = False,
+            random_seed: int = 129837697,
+    ):
+        """
+        Args:
+            n: is the image size (n * n pixels).
+            extend_label: if true extends the rectangle label to 'tall', 'wide', 'square', 'none'.
+            duplicate_functions: is the multiplier for duplicates of the functional CPTs.
+                Its minimum is 1 (no duplication) and maximum is n (fully duplicated as per Darwiche 2020).
+                If 'duplicate_functions' is outside this range, it will be clipped to the extreme (1 or n).
+                If 'duplicate_functions' is 'full' then it will be set to the maximum, n.
+        """
+        params = (n, duplicate_functions, extend_label)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        duplicate_functions = n if duplicate_functions == 'full' else duplicate_functions
+        duplicate_functions = max(1, min(duplicate_functions, n))  # clip value
+        start_duplicate_functions = n - duplicate_functions + 1
+
+        name = f'rectangle_{n}x{n}_dup({duplicate_functions})'
+        if extend_label:
+            name += '(extend_label)'
+
+        random_stream = _random.Random(random_seed).random
+        rand_iter = iter(random_stream, None)
+
+        rect_row = self.new_rv('rect_row', n)
+        rect_col = self.new_rv('rect_col', n)
+        rect_height = self.new_rv('rect_height', n)
+        rect_width = self.new_rv('rect_width', n)
+        if extend_label:
+            rect_label = self.new_rv('label', ['tall', 'wide', 'square', 'none'])
+        else:
+            rect_label = self.new_rv('label', ['tall', 'wide'])
+        rows = [self.new_rv(f'row_{i}', 2) for i in range(n)]
+        cols = [self.new_rv(f'col_{i}', 2) for i in range(n)]
+        dup_rows = [[]] * n
+        dup_cols = [[]] * n
+        for k in range(n):
+            if k < start_duplicate_functions:
+                dup_rows[k] = rows
+                dup_cols[k] = cols
+            else:
+                # Each rows[i] and cols[i] RV will be the child of a functional CPT.
+                # and there children will be all pixs[i,j]
+                # In Darwiche 2020, functional CPTs get duplicated for each child
+                dup_rows[k] = [self.new_rv(f'row_{i}_dup_{k}', 2) for i in range(n)]
+                dup_cols[k] = [self.new_rv(f'col_{i}_dup_{k}', 2) for i in range(n)]
+
+        pixs = [[self.new_rv(f'pix_{i},{j}', 2) for j in range(n)] for i in range(n)]
+
+        self.new_factor(rect_row).set_dense().set_iter(rand_iter)
+        self.new_factor(rect_col).set_dense().set_iter(rand_iter)
+
+        f_height = self.new_factor(rect_height, rect_row).set_sparse()
+        for row in range(len(rect_row)):
+            max_height = n - row
+            if max_height > 0:
+                cpd = _random_cpd(max_height - 1, 0, random_stream)  # -1 as height cannot be zero
+                for height in range(1, max_height):
+                    f_height[height, row] = cpd.item(height - 1)
+
+        f_width = self.new_factor(rect_width, rect_col).set_sparse()
+        for col in range(len(rect_col)):
+            max_width = n - col
+            if max_width > 0:
+                cpd = _random_cpd(max_width - 1, 0, random_stream)  # -1 as width cannot be zero
+                for width in range(1, max_width):
+                    f_width[width, col] = cpd.item(width - 1)
+
+        # functional relationship: rect_label <- rect_height, rect_width
+        f_label = self.new_factor(rect_label, rect_height, rect_width).set_sparse()
+        if extend_label:
+            for height in range(len(rect_height)):
+                for width in range(len(rect_width)):
+                    if height == 0 or width == 0:
+                        label = 3  # none
+                    elif height > width:
+                        label = 0  # tall
+                    elif height < width:
+                        label = 1  # wide
+                    else:
+                        label = 2  # square
+                    f_label[label, height, width] = 1
+        else:
+            for height in range(len(rect_height)):
+                for width in range(len(rect_width)):
+                    label = 0 if height > width else 1
+                    f_label[label, height, width] = 1
+
+        # functional relationship: rows[i] <- rect_row, rect_height
+        f_row = []
+        for i in range(n):
+            f_row_i = self.new_factor(rows[i], rect_row, rect_height).set_sparse()
+            f_row.append(f_row_i)
+            for row in range(len(rect_row)):
+                for height in range(len(rect_height)):
+                    if row <= i < row + height:
+                        f_row_i[1, row, height] = 1
+                    else:
+                        f_row_i[0, row, height] = 1
+
+        # functional relationship: cols[i] <- rect_col, rect_width
+        f_col = []
+        for i in range(n):
+            f_col_i = self.new_factor(cols[i], rect_col, rect_width).set_sparse()
+            f_col.append(f_col_i)
+            for col in range(len(rect_col)):
+                for width in range(len(rect_width)):
+                    if col <= i < col + width:
+                        f_col_i[1, col, width] = 1
+                    else:
+                        f_col_i[0, col, width] = 1
+
+        # patch in the potential functions for the duplicate factors
+        for k in range(start_duplicate_functions, n):
+            for i in range(n):
+                self.new_factor(dup_rows[k][i], rect_row, rect_height).function = f_row[i]
+                self.new_factor(dup_cols[k][i], rect_col, rect_width).function = f_col[i]
+
+        # connect rows and cols to pixels
+        for i in range(n):
+            for j in range(n):
+                self.new_factor(pixs[i][j], dup_rows[j][i], dup_cols[i][j]).set_dense().set_iter(rand_iter)
+
+
+def _random_cpd(size: int, sparsity: int, random_stream: Callable[[], float]):
+    cpd = _np.zeros(size)
+    if sparsity <= 0:
+        for i in range(len(cpd)):
+            cpd[i] = 0.0000001 + random_stream()
+        cpd /= _np.sum(cpd)
+    else:
+        for i in range(len(cpd)):
+            if random_stream() <= sparsity:
+                cpd[i] = 0
+            else:
+                cpd[i] = 0.0000001 + random_stream()
+        sum_value = _np.sum(cpd)
+        if sum_value > 0:
+            cpd /= sum_value
+    return cpd

ck/example/run.py

@@ -0,0 +1,30 @@
+import random as _random
+
+from ck.pgm import PGM
+
+
+class Run(PGM):
+    """
+    This PGM is the 'Run' Bayesian network.
+
+    The Run Bayesian network is a sequence of random variables, x0, x1, x2, ... .
+    The parents of each random variable are all the random variable
+    earlier in the sequence.
+    """
+
+    def __init__(
+            self,
+            vars_per_run: int = 4,
+            states_per_var: int = 2,
+            sparsity: int = 0,
+            random_seed: int = 123456,
+    ):
+        params = (vars_per_run, states_per_var, sparsity)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        random_stream = _random.Random(random_seed).random
+        for i in range(vars_per_run):
+            self.new_rv(f'x{vars_per_run - i}', states_per_var)
+            factor = self.new_factor(*tuple(reversed(self.rvs)))
+            cpt = factor.set_cpt()
+            cpt.set_random(random_stream, sparsity)

ck/example/sachs.py

@@ -0,0 +1,129 @@
+from ck.pgm import PGM
+
+
+class Sachs(PGM):
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        pgm_rv0 = self.new_rv('Akt', ('1', '2', '3'))
+        pgm_rv1 = self.new_rv('Erk', ('1', '2', '3'))
+        pgm_rv2 = self.new_rv('Jnk', ('1', '2', '3'))
+        pgm_rv3 = self.new_rv('Mek', ('1', '2', '3'))
+        pgm_rv4 = self.new_rv('P38', ('1', '2', '3'))
+        pgm_rv5 = self.new_rv('PIP2', ('1', '2', '3'))
+        pgm_rv6 = self.new_rv('PIP3', ('1', '2', '3'))
+        pgm_rv7 = self.new_rv('PKA', ('1', '2', '3'))
+        pgm_rv8 = self.new_rv('PKC', ('1', '2', '3'))
+        pgm_rv9 = self.new_rv('Plcg', ('1', '2', '3'))
+        pgm_rv10 = self.new_rv('Raf', ('1', '2', '3'))
+        pgm_factor0 = self.new_factor(pgm_rv0, pgm_rv1, pgm_rv7)
+        pgm_factor1 = self.new_factor(pgm_rv1, pgm_rv3, pgm_rv7)
+        pgm_factor2 = self.new_factor(pgm_rv2, pgm_rv7, pgm_rv8)
+        pgm_factor3 = self.new_factor(pgm_rv3, pgm_rv7, pgm_rv8, pgm_rv10)
+        pgm_factor4 = self.new_factor(pgm_rv4, pgm_rv7, pgm_rv8)
+        pgm_factor5 = self.new_factor(pgm_rv5, pgm_rv6, pgm_rv9)
+        pgm_factor6 = self.new_factor(pgm_rv6, pgm_rv9)
+        pgm_factor7 = self.new_factor(pgm_rv7, pgm_rv8)
+        pgm_factor8 = self.new_factor(pgm_rv8)
+        pgm_factor9 = self.new_factor(pgm_rv9)
+        pgm_factor10 = self.new_factor(pgm_rv10, pgm_rv7, pgm_rv8)
+
+        pgm_function0 = pgm_factor0.set_dense()
+        pgm_function0.set_flat(
+            0.6722222, 0.6204819, 0.97674419, 0.3349515, 0.8214285714,
+            0.94852941, 0.0, 0.177083333, 0.1702128, 0.3277778,
+            0.3795181, 0.02325581, 0.6650485, 0.1781954887, 0.05147059,
+            0.1182573, 0.813802083, 0.8297872, 0.0, 0.0,
+            0.0, 0.0, 0.0003759398, 0.0, 0.8817427,
+            0.009114583, 0.0
+        )
+
+        pgm_function1 = pgm_factor1.set_dense()
+        pgm_function1.set_flat(
+            0.85066667, 0.1177011, 0.07401033, 0.3870968, 0.04893754,
+            0.0, 0.00862069, 0.0, 0.0, 0.13866667,
+            0.691954, 0.70051635, 0.483871, 0.72826787, 0.1,
+            0.18793103, 0.75, 0.0, 0.01066667, 0.1903448,
+            0.22547332, 0.1290323, 0.22279459, 0.9, 0.80344828,
+            0.25, 1.0
+        )
+
+        pgm_function2 = pgm_factor2.set_dense()
+        pgm_function2.set_flat(
+            0.2899207, 0.5796178, 0.0, 0.5767013, 0.6129167,
+            0.04462475, 0.996261682, 0.8636364, 0.1538462, 0.2457531,
+            0.4203822, 1.0, 0.4232987, 0.3870833, 0.93509128,
+            0.003738318, 0.1363636, 0.8461538, 0.4643262, 0.0,
+            0.0, 0.0, 0.0, 0.02028398, 0.0,
+            0.0, 0.0
+        )
+
+        pgm_function3 = pgm_factor3.set_dense()
+        pgm_function3.set_flat(
+            0.7454545, 0.3846154, 0.26217765, 0.7068966, 0.2692308,
+            0.85106383, 0.8571429, 0.0, 0.3333333, 0.757732,
+            0.343173432, 0.86538462, 0.714826, 0.274655355, 0.2814815,
+            0.8256881, 0.1052632, 0.3333333, 0.997782705, 1.0,
+            0.9375, 0.96969697, 0.8571429, 0.5, 0.7272727,
+            0.0, 0.3333333, 0.2545455, 0.1230769, 0.001432665,
+            0.2931034, 0.7307692, 0.10638298, 0.1428571, 1.0,
+            0.3333333, 0.242268, 0.649446494, 0.10096154, 0.285174,
+            0.720042418, 0.5851852, 0.1743119, 0.8947368, 0.3333333,
+            0.002217295, 0.0, 0.0, 0.03030303, 0.1428571,
+            0.5, 0.2727273, 1.0, 0.3333333, 0.0,
+            0.4923077, 0.736389685, 0.0, 0.0, 0.04255319,
+            0.0, 0.0, 0.3333333, 0.0, 0.007380074,
+            0.03365385, 0.0, 0.005302227, 0.1333333, 0.0,
+            0.0, 0.3333333, 0.0, 0.0, 0.0625,
+            0.0, 0.0, 0.0, 0.0, 0.0,
+            0.3333333
+        )
+
+        pgm_function4 = pgm_factor4.set_dense()
+        pgm_function4.set_flat(
+            0.30690827, 0.656051, 0.875, 0.919261822, 0.815,
+            0.803245436, 0.80747664, 0.3863636, 0.7692308, 0.06455266,
+            0.343949, 0.125, 0.078431373, 0.185, 0.192697769,
+            0.09158879, 0.1590909, 0.2307692, 0.62853907, 0.0,
+            0.0, 0.002306805, 0.0, 0.004056795, 0.10093458,
+            0.4545455, 0.0
+        )
+
+        pgm_function5 = pgm_factor5.set_dense()
+        pgm_function5.set_flat(
+            0.996868476, 1.0, 0.2217573, 0.98674822, 0.95789474,
+            0.0766129, 0.872442019, 0.521875, 0.02597403, 0.003131524,
+            0.0, 0.4937238, 0.01325178, 0.04210526, 0.391129,
+            0.12005457, 0.4625, 0.05194805, 0.0, 0.0,
+            0.2845188, 0.0, 0.0, 0.5322581, 0.007503411,
+            0.015625, 0.92207792
+        )
+
+        pgm_function6 = pgm_factor6.set_dense()
+        pgm_function6.set_flat(
+            0.2184223, 0.07777778, 0.4237589, 0.4473324, 0.21111111,
+            0.4397163, 0.3342453, 0.71111111, 0.1365248
+        )
+
+        pgm_function7 = pgm_factor7.set_dense()
+        pgm_function7.set_flat(
+            0.3864333, 0.0603614, 0.0155642, 0.3794311, 0.92272203,
+            0.95914397, 0.2341357, 0.01691657, 0.02529183
+        )
+
+        pgm_function8 = pgm_factor8.set_dense()
+        pgm_function8.set_flat(0.42314815, 0.48166667, 0.09518519)
+
+        pgm_function9 = pgm_factor9.set_dense()
+        pgm_function9.set_flat(0.81222222, 0.08333333, 0.10444444)
+
+        pgm_function10 = pgm_factor10.set_dense()
+        pgm_function10.set_flat(
+            0.06228766, 0.3694268, 0.875, 0.4475202, 0.5508333,
+            0.8843813, 0.84299065, 0.75, 0.8461538, 0.14722537,
+            0.3312102, 0.125, 0.3125721, 0.3929167, 0.1156187,
+            0.1271028, 0.15909091, 0.1538462, 0.79048698, 0.2993631,
+            0.0, 0.2399077, 0.05625, 0.0, 0.02990654,
+            0.09090909, 0.0
+        )

ck/example/sprinkler.py

@@ -0,0 +1,30 @@
+from ck.pgm import PGM
+
+
+class Sprinkler(PGM):
+    """
+    This PGM is the well known, pedagogical 'Sprinkler' Bayesian network.
+    """
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        rain = self.new_rv('rain', ['not raining', 'raining'])
+        sprinkler = self.new_rv('sprinkler', ['off', 'on'])
+        grass = self.new_rv('grass', ['dry', 'damp', 'wet'])
+
+        f_g = self.new_factor(grass, rain, sprinkler)
+        f_r = self.new_factor(rain)
+        f_s = self.new_factor(sprinkler)
+
+        f_r.set_dense().set_flat(0.8, 0.2)
+        f_s.set_dense().set_flat(0.9, 0.1)
+        # fmt: off
+        f_g.set_dense().set_flat(
+            # not raining, raining   # rain
+            # off, on,     off,  on  # sprinkler
+            0.90, 0.01, 0.02, 0.01,  # grass dry
+            0.09, 0.01, 0.08, 0.04,  # grass damp
+            0.01, 0.98, 0.90, 0.95,  # grass wet
+        )
+        # fmt: on

ck/example/star.py

@@ -0,0 +1,44 @@
+import random as _random
+
+from ck.pgm import PGM
+
+
+class Star(PGM):
+    """
+    This PGM is the 'Star' factor graph.
+
+    The Star factor graph is where the first random variable, x0, is
+    connected to each of the other random variables, x1, x2, ..., via a binary factor.
+    If include_unaries then, also includes one unary factor per random variable.
+    """
+
+    def __init__(
+            self,
+            num_of_arms: int = 3,
+            length_of_arms: int = 2,
+            states_per_var: int = 2,
+            include_unaries: bool = True,
+            random_seed: int = 123456,
+    ):
+        params = (num_of_arms, length_of_arms, states_per_var, include_unaries)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        random_stream = _random.Random(random_seed).random
+        rand_iter = iter(random_stream, None)
+
+        x0 = self.new_rv('x0', states_per_var)
+        arms = [
+            [self.new_rv(f'x{arm}_{i}', states_per_var) for i in range(length_of_arms)]
+            for arm in range(num_of_arms)
+        ]
+
+        for arm in arms:
+            self.new_factor(x0, arm[0]).set_dense().set_iter(rand_iter)
+            for i in range(1, len(arm)):
+                self.new_factor(arm[i - 1], arm[i]).set_dense().set_iter(rand_iter)
+
+        if include_unaries:
+            self.new_factor(x0).set_dense().set_iter(rand_iter)
+            for arm in arms:
+                for rv in arm:
+                    self.new_factor(rv).set_dense().set_iter(rand_iter)

ck/example/stress.py

@@ -0,0 +1,64 @@
+from ck.pgm import PGM
+
+
+class Stress(PGM):
+    """
+    This PGM is the 'Stress' factor graph.
+
+    The Stress factor graph uses many of the different PGM software
+    components. This can be used to stress test the PGM implementation
+    and processing pipelines.
+    """
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        no_name = self.new_rv('', 2)
+        x1 = self.new_rv('x1', 2)
+        x2 = self.new_rv('x2', ['one', 'two'])
+        x3 = self.new_rv('x3', ['one', 'two', 'non-ascii 😊'])
+        x4 = self.new_rv('x4', [1.1, 1.23, None, 'string'])
+        x5 = self.new_rv('x5', 3)
+        A = self.new_rv('A', 2)
+        B = self.new_rv('B', 2)
+        C = self.new_rv('C', 2)
+        D = self.new_rv('D', 2)
+        E = self.new_rv('E', [True, False])
+
+        self.new_factor(no_name).set_zero()
+
+        self.new_factor(x1).set_dense().set_flat(1, 2)
+
+        self.new_factor(x1, x2).set_clause(1, 0)
+
+        self.new_factor(x2, x3).set_cpt().set_all(
+            (0.1, 0.9),
+            (0.2, 0.8),
+            (0.3, 0.7),
+        )
+
+        f_3_4 = self.new_factor(x3, x4).set_sparse()
+        f_3_4[0, 0] = 11
+        f_3_4[1, 1] = 11
+        f_3_4[2, 2] = 22
+
+        f_4_5 = self.new_factor(x4, x5).set_compact()
+        f_4_5[0, 0] = 11
+        f_4_5[1, 1] = 11
+        f_4_5[2, 2] = 22
+
+        f_ab = self.new_factor(A, B)
+        f_ab.set_dense().set_flat(2, 3, 5, 7)
+
+        self.new_factor(A, C).set_sparse()[0, 1] = 11
+        self.new_factor(A, D).set_sparse()[1, 0] = 13
+        self.new_factor(B, C).set_clause(0, 1)
+        self.new_factor(B, D).set_cpt().set_all([0.2, 0.8], [0.3, 0.7])
+
+        self.new_factor(A, E)  # leave with no potential function
+
+        self.new_factor(B, E).function = f_ab.function  # shared function
+
+        # Two factors on the same random variables
+        self.new_factor(C, E).set_sparse()
+        self.new_factor(C, E).set_sparse()

ck/example/student.py

@@ -0,0 +1,43 @@
+from ck.pgm import PGM
+
+
+class Student(PGM):
+    """
+    This PGM is the well known, pedagogical 'Student' Bayesian network.
+
+    Reference:
+    Probabilistic Graphical Models: Principles and Techniques
+    Daphne Koller & Nir Friedman. MIT Press, 2009.
+    Figure 3.1, page 48.
+    """
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        difficult = self.new_rv('difficult', ('Yes', 'No'))
+        intelligent = self.new_rv('intelligent', ('Yes', 'No'))
+        grade = self.new_rv('grade', ('1', '2', '3'))
+        sat = self.new_rv('sat', ('High', 'Low'))
+        letter = self.new_rv('letter', ('Yes', 'No'))
+
+        self.new_factor(difficult).set_cpt().set_all(
+            (0.6, 0.4),
+        )
+        self.new_factor(intelligent).set_cpt().set_all(
+            (0.7, 0.3),
+        )
+        self.new_factor(grade, difficult, intelligent).set_cpt().set_all(
+            (0.3, 0.4, 0.3),
+            (0.05, 0.25, 0.7),
+            (0.9, 0.08, 0.02),
+            (0.5, 0.3, 0.2)
+        )
+        self.new_factor(sat, intelligent).set_cpt().set_all(
+            (0.95, 0.05),
+            (0.2, 0.8),
+        )
+        self.new_factor(letter, grade).set_cpt().set_all(
+            (0.1, 0.9),
+            (0.4, 0.6),
+            (0.99, 0.01),
+        )

ck/example/survey.py

@@ -0,0 +1,46 @@
+from ck.pgm import PGM
+
+
+class Survey(PGM):
+
+    def __init__(self):
+        super().__init__(self.__class__.__name__)
+
+        pgm_rv0 = self.new_rv('A', ('young', 'adult', 'old'))
+        pgm_rv1 = self.new_rv('S', ('M', 'F'))
+        pgm_rv2 = self.new_rv('E', ('high', 'uni'))
+        pgm_rv3 = self.new_rv('O', ('emp', 'self'))
+        pgm_rv4 = self.new_rv('R', ('small', 'big'))
+        pgm_rv5 = self.new_rv('T', ('car', 'train', 'other'))
+        pgm_factor0 = self.new_factor(pgm_rv0)
+        pgm_factor1 = self.new_factor(pgm_rv1)
+        pgm_factor2 = self.new_factor(pgm_rv2, pgm_rv0, pgm_rv1)
+        pgm_factor3 = self.new_factor(pgm_rv3, pgm_rv2)
+        pgm_factor4 = self.new_factor(pgm_rv4, pgm_rv2)
+        pgm_factor5 = self.new_factor(pgm_rv5, pgm_rv3, pgm_rv4)
+
+        pgm_function0 = pgm_factor0.set_dense()
+        pgm_function0.set_flat(0.3, 0.5, 0.2)
+
+        pgm_function1 = pgm_factor1.set_dense()
+        pgm_function1.set_flat(0.6, 0.4)
+
+        pgm_function2 = pgm_factor2.set_dense()
+        pgm_function2.set_flat(
+            0.75, 0.64, 0.72, 0.7, 0.88,
+            0.9, 0.25, 0.36, 0.28, 0.3,
+            0.12, 0.1
+        )
+
+        pgm_function3 = pgm_factor3.set_dense()
+        pgm_function3.set_flat(0.96, 0.92, 0.04, 0.08)
+
+        pgm_function4 = pgm_factor4.set_dense()
+        pgm_function4.set_flat(0.25, 0.2, 0.75, 0.8)
+
+        pgm_function5 = pgm_factor5.set_dense()
+        pgm_function5.set_flat(
+            0.48, 0.58, 0.56, 0.7, 0.42,
+            0.24, 0.36, 0.21, 0.1, 0.18,
+            0.08, 0.09
+        )

ck/example/triangle_square.py

@@ -0,0 +1,54 @@
+import random as _random
+
+from ck.pgm import PGM
+
+
+class TriangleSquare(PGM):
+    r"""
+    This PGM is the 'TriangleSquare' factor graph.
+
+    The TriangleSquare is a factor graph with six random variables (a, b, c, ..., f).
+    Binary factors are between pairs of random variables crating the pattern:
+                  b -- d
+                / |    | \
+               a  |    |  f
+                \ |    | /
+                  c -- e
+    If include_unaries then, also includes one unary factor per random variable.
+    """
+
+    def __init__(
+            self,
+            states_per_var=2,
+            include_unaries=True,
+            random_seed=123456
+    ):
+        params = (states_per_var, include_unaries)
+        super().__init__(f'{self.__class__.__name__}({",".join(str(param) for param in params)})')
+
+        random_stream = _random.Random(random_seed).random
+        rand_iter = iter(random_stream, None)
+
+        a = self.new_rv('a', states_per_var)
+        b = self.new_rv('b', states_per_var)
+        c = self.new_rv('c', states_per_var)
+        d = self.new_rv('d', states_per_var)
+        e = self.new_rv('e', states_per_var)
+        f = self.new_rv('f', states_per_var)
+
+        self.new_factor(a, b).set_dense().set_iter(rand_iter)
+        self.new_factor(a, c).set_dense().set_iter(rand_iter)
+        self.new_factor(b, c).set_dense().set_iter(rand_iter)
+        self.new_factor(b, d).set_dense().set_iter(rand_iter)
+        self.new_factor(c, e).set_dense().set_iter(rand_iter)
+        self.new_factor(d, e).set_dense().set_iter(rand_iter)
+        self.new_factor(d, f).set_dense().set_iter(rand_iter)
+        self.new_factor(e, f).set_dense().set_iter(rand_iter)
+
+        if include_unaries:
+            self.new_factor(a).set_dense().set_iter(rand_iter)
+            self.new_factor(b).set_dense().set_iter(rand_iter)
+            self.new_factor(c).set_dense().set_iter(rand_iter)
+            self.new_factor(d).set_dense().set_iter(rand_iter)
+            self.new_factor(e).set_dense().set_iter(rand_iter)
+            self.new_factor(f).set_dense().set_iter(rand_iter)