Post meeting 2022-12-05

Francisco Coelho
1 parent 7ae9c686
Showing 6 changed files with 152 additions and 2 deletions Show diff stats
.vscode/settings.json
code/python/__init__.py
code/python/__pycache__/event_lattice.cpython-39.pyc
code/python/api_01.py
code/python/event_lattice.py
code/python/explore_01.py
@@ -0,0 +1,5 @@
+{
+    "cSpell.words": [
+        "smodels"
+    ]
+}
 \ No newline at end of file
@@ -23,4 +23,4 @@ ctl.ground(
  
 s = ctl.solve(on_model=on_model)
  
-print(dir(s))
 \ No newline at end of file
+print(s)
 \ No newline at end of file
@@ -0,0 +1,145 @@
+import math
+from functools import cache
+from itertools import accumulate
+import operator
+
+
+def uniform_op(x):
+    n = len(list(x))
+    return 0.0 if n == 0 else 1.0/n
+
+
+def max_op(x):
+    return max(x)
+
+
+def min_op(x):
+    return min(x)
+
+
+def sum_op(x):
+    return sum(x)
+
+
+def prod_op(x):
+    log_x = map(math.log, x)
+    return math.exp(sum(log_x))
+
+
+def co(x):
+    if isinstance(x, float) or isinstance(x, int):
+        return 1 - x
+    elif isinstance(x, str):
+        return x.swapcase()
+    else:
+        return x
+
+
+def parse(d):
+    """Structures a string as an Event and a dict as a base of stable models."""
+    if isinstance(d, str):
+        return frozenset(d)
+    elif isinstance(d, dict):
+        result = dict()
+        for k, v in d.items():
+            key = parse(k)
+            result[key] = v
+        return result
+    else:
+        return d
+
+
+def is_consistent(event):
+    return all(x.swapcase() not in event for x in event)
+
+
+class EventsLattice:
+
+    @staticmethod
+    def close_literals(base_literals):
+        base_lits = list(accumulate(base_literals, func=operator.or_))[-1]
+        lits = set([])
+        for x in base_lits:
+            lits.add(x)
+            lits.add(x.swapcase())
+        return lits
+
+    def __init__(self, smodels):
+        """Create base for Events Lattice."""
+        self._smodels = smodels
+        self._literals = EventsLattice.close_literals(self._smodels.keys())
+
+    def literals(self):
+        return self._literals
+
+    def stable_models(self):
+        return list(map(set, self._smodels.keys()))
+
+    @cache
+    def lower_bound(self, event):
+        return set(filter(lambda sm: sm <= event, self._smodels))
+
+    @cache
+    def upper_bound(self, event):
+        return set(filter(lambda sm: event <= sm, self._smodels))
+
+    def related(self, u, v):
+        u_consistent = is_consistent(u)
+        v_consistent = is_consistent(v)
+        if u_consistent and (u_consistent == v_consistent):
+            return \
+                self.lower_bound(u) == self.lower_bound(v) and \
+                self.upper_bound(u) == self.upper_bound(v)
+        else:
+            return u_consistent == v_consistent
+
+    def factors(self, event):
+        pass
+
+    def propagated_value(self, event, lower_op=sum_op, upper_op=prod_op):
+        value = 0.0
+
+        lb = self.lower_bound(event)
+        len_lb = len(lb)
+        if len_lb > 1:
+            value = lower_op(map(lambda sm: self._smodels[sm], lb))
+        elif len_lb == 1:
+            value = self._smodels[event]
+        else:
+            ub = self.upper_bound(event)
+            len_ub = len(ub)
+            if len_ub > 1:
+                value = upper_op(map(lambda sm: self._smodels[sm], ub))
+            elif len_ub == 1:
+                value = self._smodels[event]
+
+        return value
+
+
+def zoom_event(event_str, lattice, lower_op=sum_op, upper_op=prod_op):
+    event = parse(event_str)
+    lower_bound = lattice.lower_bound(event)
+    upper_bound = lattice.upper_bound(event)
+    propagated = lattice.propagated_value(
+        event, lower_op=lower_op, upper_op=upper_op)
+    print(
+        f"Event: {event}\n\tLB: {lower_bound}\n\tUB: {upper_bound}\n\tProp: {propagated}")
+
+
+if __name__ == "__main__":
+
+    smodels = parse({
+        "A": 0.7,
+        "ab": 2 * 3,
+        "ac": 5 * 7
+    })
+
+    lattice = EventsLattice(smodels)
+
+    print(
+        f"Literals: {lattice.literals()}\nStable Models: {lattice.stable_models()}")
+
+    zoom_event("abc", lattice, upper_op=min_op, lower_op=max_op)
+
+    print(is_consistent(parse("aBacc")))
+    print(is_consistent(parse("aBabc")))
@@ -6,7 +6,7 @@ ctl_a = Control()
 ctl_a.register_observer(ProgramObserver(prg))
 print(f"<1>\n{prg}\n</1>")
  
-prog = "/home/fc/sci/projetos/plp/code/asp/tutotial_01.lp"     
+prog = "code/asp/alarm.lp"     
 ctl_a.load(prog)
 ctl_a.ground([('base', [])])
 print(f"<2>\n{prg}\n</2>")
...	...	@@ -0,0 +1,5 @@
	1	+{
	2	+ "cSpell.words": [
	3	+ "smodels"
	4	+ ]
	5	+}
0	6	\ No newline at end of file
...	...
...	...	@@ -23,4 +23,4 @@ ctl.ground(
23	23
24	24	s = ctl.solve(on_model=on_model)
25	25
26		-print(dir(s))
27	26	\ No newline at end of file
	27	+print(s)
28	28	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,145 @@
	1	+import math
	2	+from functools import cache
	3	+from itertools import accumulate
	4	+import operator
	5	+
	6	+
	7	+def uniform_op(x):
	8	+ n = len(list(x))
	9	+ return 0.0 if n == 0 else 1.0/n
	10	+
	11	+
	12	+def max_op(x):
	13	+ return max(x)
	14	+
	15	+
	16	+def min_op(x):
	17	+ return min(x)
	18	+
	19	+
	20	+def sum_op(x):
	21	+ return sum(x)
	22	+
	23	+
	24	+def prod_op(x):
	25	+ log_x = map(math.log, x)
	26	+ return math.exp(sum(log_x))
	27	+
	28	+
	29	+def co(x):
	30	+ if isinstance(x, float) or isinstance(x, int):
	31	+ return 1 - x
	32	+ elif isinstance(x, str):
	33	+ return x.swapcase()
	34	+ else:
	35	+ return x
	36	+
	37	+
	38	+def parse(d):
	39	+ """Structures a string as an Event and a dict as a base of stable models."""
	40	+ if isinstance(d, str):
	41	+ return frozenset(d)
	42	+ elif isinstance(d, dict):
	43	+ result = dict()
	44	+ for k, v in d.items():
	45	+ key = parse(k)
	46	+ result[key] = v
	47	+ return result
	48	+ else:
	49	+ return d
	50	+
	51	+
	52	+def is_consistent(event):
	53	+ return all(x.swapcase() not in event for x in event)
	54	+
	55	+
	56	+class EventsLattice:
	57	+
	58	+ @staticmethod
	59	+ def close_literals(base_literals):
	60	+ base_lits = list(accumulate(base_literals, func=operator.or_))[-1]
	61	+ lits = set([])
	62	+ for x in base_lits:
	63	+ lits.add(x)
	64	+ lits.add(x.swapcase())
	65	+ return lits
	66	+
	67	+ def __init__(self, smodels):
	68	+ """Create base for Events Lattice."""
	69	+ self._smodels = smodels
	70	+ self._literals = EventsLattice.close_literals(self._smodels.keys())
	71	+
	72	+ def literals(self):
	73	+ return self._literals
	74	+
	75	+ def stable_models(self):
	76	+ return list(map(set, self._smodels.keys()))
	77	+
	78	+ @cache
	79	+ def lower_bound(self, event):
	80	+ return set(filter(lambda sm: sm <= event, self._smodels))
	81	+
	82	+ @cache
	83	+ def upper_bound(self, event):
	84	+ return set(filter(lambda sm: event <= sm, self._smodels))
	85	+
	86	+ def related(self, u, v):
	87	+ u_consistent = is_consistent(u)
	88	+ v_consistent = is_consistent(v)
	89	+ if u_consistent and (u_consistent == v_consistent):
	90	+ return \
	91	+ self.lower_bound(u) == self.lower_bound(v) and \
	92	+ self.upper_bound(u) == self.upper_bound(v)
	93	+ else:
	94	+ return u_consistent == v_consistent
	95	+
	96	+ def factors(self, event):
	97	+ pass
	98	+
	99	+ def propagated_value(self, event, lower_op=sum_op, upper_op=prod_op):
	100	+ value = 0.0
	101	+
	102	+ lb = self.lower_bound(event)
	103	+ len_lb = len(lb)
	104	+ if len_lb > 1:
	105	+ value = lower_op(map(lambda sm: self._smodels[sm], lb))
	106	+ elif len_lb == 1:
	107	+ value = self._smodels[event]
	108	+ else:
	109	+ ub = self.upper_bound(event)
	110	+ len_ub = len(ub)
	111	+ if len_ub > 1:
	112	+ value = upper_op(map(lambda sm: self._smodels[sm], ub))
	113	+ elif len_ub == 1:
	114	+ value = self._smodels[event]
	115	+
	116	+ return value
	117	+
	118	+
	119	+def zoom_event(event_str, lattice, lower_op=sum_op, upper_op=prod_op):
	120	+ event = parse(event_str)
	121	+ lower_bound = lattice.lower_bound(event)
	122	+ upper_bound = lattice.upper_bound(event)
	123	+ propagated = lattice.propagated_value(
	124	+ event, lower_op=lower_op, upper_op=upper_op)
	125	+ print(
	126	+ f"Event: {event}\n\tLB: {lower_bound}\n\tUB: {upper_bound}\n\tProp: {propagated}")
	127	+
	128	+
	129	+if __name__ == "__main__":
	130	+
	131	+ smodels = parse({
	132	+ "A": 0.7,
	133	+ "ab": 2 * 3,
	134	+ "ac": 5 * 7
	135	+ })
	136	+
	137	+ lattice = EventsLattice(smodels)
	138	+
	139	+ print(
	140	+ f"Literals: {lattice.literals()}\nStable Models: {lattice.stable_models()}")
	141	+
	142	+ zoom_event("abc", lattice, upper_op=min_op, lower_op=max_op)
	143	+
	144	+ print(is_consistent(parse("aBacc")))
	145	+ print(is_consistent(parse("aBabc")))
...	...
...	...	@@ -6,7 +6,7 @@ ctl_a = Control()
6	6	ctl_a.register_observer(ProgramObserver(prg))
7	7	print(f"<1>\n{prg}\n</1>")
8	8
9		-prog = "/home/fc/sci/projetos/plp/code/asp/tutotial_01.lp"
	9	+prog = "code/asp/alarm.lp"
10	10	ctl_a.load(prog)
11	11	ctl_a.ground([('base', [])])
12	12	print(f"<2>\n{prg}\n</2>")
...	...