diff options
Diffstat (limited to '')
| -rw-r--r-- | src/act4e_solutions/semigroups_morphisms.py | 49 | ||||
| -rw-r--r-- | src/act4e_solutions/semigroups_morphisms_representation.py | 99 |
2 files changed, 142 insertions, 6 deletions
diff --git a/src/act4e_solutions/semigroups_morphisms.py b/src/act4e_solutions/semigroups_morphisms.py new file mode 100644 index 0000000..5d832ee --- /dev/null +++ b/src/act4e_solutions/semigroups_morphisms.py @@ -0,0 +1,49 @@ +from typing import Any, TypeVar + +from .semigroups_representation import MyFiniteSemigroup, MyFiniteMonoid, MyFiniteGroup + +import act4e_interfaces as I + +A = TypeVar("A") +B = TypeVar("B") + + +class SolFiniteSemigroupMorphismsChecks(I.FiniteSemigroupMorphismsChecks): + def is_semigroup_morphism(self, a: I.FiniteSemigroup[A], b: I.FiniteSemigroup[B], f: I.FiniteMap[A, B]) -> bool: + # Semigroup preserves the structure + # f(xy) = f(x) f(y) for all x, y in a + # converse: + # there is an x or a y in a such that + # f(xy) neq f(x) f(y) + for x in a.carrier().elements(): + for y in a.carrier().elements(): + inside = f(a.compose(x, y)) + outside = b.compose(f(x), f(y)) + if not b.carrier().equal(inside, outside): + return False + return True + + def is_monoid_morphism(self, a: I.FiniteMonoid[A], b: I.FiniteMonoid[B], f: I.FiniteMap[A, B]) -> bool: + # Monoid morphism is a semigroup morphism that maps identity to identity + if not self.is_semigroup_morphism(a, b, f): + return False + + if not b.carrier().equal(b.identity(), f(a.identity())): + return False + + return True + + + def is_group_morphism(self, a: I.FiniteGroup[A], b: I.FiniteGroup[B], f: I.FiniteMap[A, B]) -> bool: + # Group morphism preserve + # f(xy) = f(x)f(y) for all x, y in a + # converse is + # exists x, y in a such that + # f(xy) neq f(x)f(y) + for x in a.carrier().elements(): + for y in a.carrier().elements(): + inside = f(a.compose(x, y)) + outside = b.compose(f(x), f(y)) + if not b.carrier().equal(inside, outside): + return False + return True diff --git a/src/act4e_solutions/semigroups_morphisms_representation.py b/src/act4e_solutions/semigroups_morphisms_representation.py index 43df89f..abc2216 100644 --- a/src/act4e_solutions/semigroups_morphisms_representation.py +++ b/src/act4e_solutions/semigroups_morphisms_representation.py @@ -2,26 +2,113 @@ from typing import Any, TypeVar import act4e_interfaces as I +from .maps_representation import SolFiniteMapRepresentation +from .semigroups_representation import (MyFiniteSemigroup, MyFiniteMonoid, MyFiniteGroup, + SolFiniteSemigroupRepresentation, + SolFiniteMonoidRepresentation, + SolFiniteGroupRepresentation) + +A = TypeVar("A") +B = TypeVar("B") + +class MyFiniteSemigroupMorphism(I.FiniteSemigroupMorphism[A, B]): + _source: I.FiniteSemigroup[A] + _target: I.FiniteSemigroup[B] + _mapping: I.FiniteMap[A, B] + + def __init__(self, s: I.FiniteSemigroup[A], t: I.FiniteSemigroup[B], f: I.FiniteMap[A, B]): + self._source = s + self._target = t + self._mapping = f + + def source(self) -> I.FiniteSemigroup[A]: + return self._source + + def target(self) -> I.FiniteSemigroup[B]: + return self._target + + def mapping(self) -> I.FiniteMap[A, B]: + return self._mapping + + +class MyFiniteMonoidMorphism(MyFiniteSemigroupMorphism, I.FiniteMonoidMorphism[A, B]): + _source: I.FiniteMonoid[A] + _target: I.FiniteMonoid[B] + + +class MyFiniteGroupMorphism(MyFiniteMonoidMorphism, I.FiniteGroupMorphism[A, B]): + _source: I.FiniteGroup[A] + _target: I.FiniteGroup[B] + + class SolFiniteSemigroupMorphismRepresentation(I.FiniteSemigroupMorphismRepresentation): def load(self, h: I.IOHelper, s: I.FiniteSemigroupMorphism_desc) -> I.FiniteSemigroupMorphism[Any, Any]: - raise NotImplementedError() + if not all(k in s.keys() for k in ["source", "target", "mapping"]): + raise I.InvalidFormat() + + fsgr = SolFiniteSemigroupRepresentation() + fmr = SolFiniteMapRepresentation() + + A = fsgr.load(h, s["source"]) + B = fsgr.load(h, s["target"]) + f = fmr.load(h, s["mapping"]) + + return MyFiniteSemigroupMorphism(A, B, f) def save(self, h: I.IOHelper, m: I.FiniteSemigroupMorphism[Any, Any]) -> I.FiniteSemigroupMorphism_desc: - raise NotImplementedError() + fsgr = SolFiniteSemigroupRepresentation() + fmr = SolFiniteMapRepresentation() + + d = {"source": fsgr.save(h, m.source()), + "target": fsgr.save(h, m.target()), + "mapping": fmr.save(h, m.mapping())} + return d class SolFiniteMonoidMorphismRepresentation(I.FiniteMonoidMorphismRepresentation): def load(self, h: I.IOHelper, s: I.FiniteMonoidMorphism_desc) -> I.FiniteMonoidMorphism[Any, Any]: - raise NotImplementedError() + if not all(k in s.keys() for k in ["source", "target", "mapping"]): + raise I.InvalidFormat() + + fmor = SolFiniteMonoidRepresentation() + fmr = SolFiniteMapRepresentation() + + A = fmor.load(h, s["source"]) + B = fmor.load(h, s["target"]) + f = fmr.load(h, s["mapping"]) + + return MyFiniteMonoidMorphism(A, B, f) def save(self, h: I.IOHelper, m: I.FiniteMonoidMorphism[Any, Any]) -> I.FiniteMonoidMorphism_desc: - raise NotImplementedError() + fmor = SolFiniteMonoidRepresentation() + fmr = SolFiniteMapRepresentation() + + d = {"source": fmor.save(h, m.source()), + "target": fmor.save(h, m.target()), + "mapping": fmr.save(h, m.mapping())} + return d class SolFiniteGroupMorphismRepresentation(I.FiniteGroupMorphismRepresentation): def load(self, h: I.IOHelper, s: I.FiniteGroupMorphism_desc) -> I.FiniteGroupMorphism[Any, Any]: - raise NotImplementedError() + if not all(k in s.keys() for k in ["source", "target", "mapping"]): + raise I.InvalidFormat() + + fgr = SolFiniteGroupRepresentation() + fmr = SolFiniteMapRepresentation() + + A = fgr.load(h, s["source"]) + B = fgr.load(h, s["target"]) + f = fmr.load(h, s["mapping"]) + + return MyFiniteGroupMorphism(A, B, f) def save(self, h: I.IOHelper, m: I.FiniteGroupMorphism[Any, Any]) -> I.FiniteGroupMorphism_desc: - raise NotImplementedError() + fgr = SolFiniteGroupRepresentation() + fmr = SolFiniteMapRepresentation() + + d = {"source": fgr.save(h, m.source()), + "target": fgr.save(h, m.target()), + "mapping": fmr.save(h, m.mapping())} + return d |