-
Notifications
You must be signed in to change notification settings - Fork 0
/
utils.py
88 lines (75 loc) · 2.52 KB
/
utils.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#!/usr/bin/env python
# -*- coding: utf8 -*-
def minimals(sigma):
"""
Dado un conjunto de congruencias `sigma` devuelve las minimales
"""
result = [tita for tita in sigma if all(
[not(tita > delta) for delta in sigma]
)]
return result
def antichain(deltas, tita):
"""
Dado un conjuntos de congruencias `deltas` y una congruencia nueva `tita`,
decide si `tita` es incomparable con las congruencias de `deltas`
"""
for delta in deltas:
if tita <= delta or delta <= tita:
return False
return True
def gen_roots(elements, delta):
"""
Dado un conjunto de elementos `elements` y una congruencia `delta`,
devuelve los representantes en `delta` para cada elemento en `elements`
"""
result = []
for x in elements:
root = delta.root(x)
if root not in result:
result.append(root)
return result
def extend_const_sys(projective, deltas, tita):
"""
Dado un conjunto de congruencias y una congruencia nueva, genera sistemas
sin solucion con los primeros elementos constantes
"""
gammas = []
for delta in deltas:
gammas.append(projective.join(tita, delta))
universe = tita.algebra.universe.copy()
output = []
n = len(deltas)
if n == 0:
return output
while universe:
a = universe.pop()
blocks = [gamma.block(a) for gamma in gammas]
elements = frozenset.intersection(*blocks)
blocks = [delta.block(a) for delta in deltas]
solutions = frozenset.intersection(*blocks)
elements_roots = gen_roots(elements - solutions, tita)
for z in elements_roots:
if solutions.intersection(tita.block(z)) == frozenset({}):
a_tuple = n * [a]
output.append(a_tuple + [z])
universe = [x for x in universe if x not in solutions]
return output
def extend_non_sol_sys(projective, deltas, tita, vector):
"""
Dado un conjunto de sismtemas de congruencias sin solucion y una
congruencia nueva, extiende el sistema a nuevos sistemas sin solucion
"""
output = []
n = len(deltas)
blocks = [(projective.join(
tita,
deltas[k]
)).block(vector[k]) for k in range(n)]
elements = frozenset.intersection(*blocks)
elements_roots = gen_roots(elements, tita)
for z in elements_roots:
output.append(vector + [z])
return output
if __name__ == "__main__":
import doctest
doctest.testmod()