Structure.sage

from typing import Iterator

class Structure ( object ) :

    def __eq__ ( self , other:"Structure" ) -> bool :
        """Tests if two objects of the same class and if they coincide."""
        if isinstance( other , self.__class__ ) :
            if self.__repr__() == other.__repr__() : return True
            else : return False
        else : return False


    def __getitem__ ( self , Input:int or slice ) -> "Structure" or list[ "Structure" ] :
        """Returns a single datum or slices of data."""
        if Input in ZZ :
            Index = Input
            if   Index <= -len(self)-1 :         return None
            elif Index in [ -len(self) .. -1 ] : Index += len(self)
            elif Index in [ 0 .. len(self) ] :   pass
            else :                               return None
            Single_Part = self.Constituent_Parts()[Index]
            return Single_Part

        elif isinstance( Input , slice ) :
            Slice = Input
            New_Constituent_Parts = self.Constituent_Parts()[Slice]
            if   len(New_Constituent_Parts) == 0 :
                return None
            elif len(New_Constituent_Parts) == 1 :
                Single_Part = New_Constituent_Parts[0]
                return Single_Part
            else :
                return self.__class__( New_Constituent_Parts )

        else :
            raise ValueError('The variable ``Input`` is inappropriate.')


    def __ne__ ( self , other:"Structure" ) -> bool :
        """Tests if two objects do not coincide."""
        return not self == other


    def Is_Irreducible ( self ) -> bool :
        """Tests if ``self`` is irreducible/ simple."""
        return len(self) == 1


    def Is_Not_Trivial ( self ) -> bool :
        """Tests if ``self`` is not trivial."""
        return not self.Is_Trivial()


    def Is_Reducible ( self ) -> bool :
        """Tests if ``self`` is reducible/ non-simple, i.e. it is trivial/ zero or consists of multiple summands/ components."""
        return not self.Is_Irreducible()


    # Synonyms for the method ``Is_Irreducible``
    def Is_Simple ( self ) -> bool :
        """Tests if ``self`` is irreducible/ simple, i.e. consists only of a single summand/ component."""
        return self.Is_Irreducible()


    def Is_Trivial ( self ) -> bool :
        """Tests if ``self`` has no components."""
        return len(self) == 0



class Irreducible_Structure ( Structure ) :

    def __iter__ ( self ) -> Iterator[ "Irreducible_Structure" ] :
        """Returns an iterator of ``self``."""
        yield self


    def __len__ ( self ) -> int :
        """Returns the number of components of ``self``."""
        return 1


    def Constituent_Parts ( self ) -> list[ "Irreducible_Structure" ] :
        """Returns ``self`` in a list ."""
        return [ self ]


    def Irreducible_Components ( self ) -> Iterator[ "Irreducible_Structure" ] :
        """Returns ``self``."""
        yield self



class Direct_Sum_Of_Structures ( Structure ) :

    def __eq__ ( self , other:"Direct_Sum_Of_Structures" ) -> bool :
        """Tests if two objects of the class ``Direct_Sum_Of_Structures`` coincide."""
        if type( other ) == self.__class__ :
            if len( other ) == len( self ) :

                Remaining_Summands = other.Summands()
                for Summand in self.Summands() :
                    try : Remaining_Summands.remove( Summand )
                    except : return False

                if len( Remaining_Summands ) == 0 : return True

                else : return False
            else : return False
        else : return False


    def __iter__ ( self ) -> Iterator[ Structure ] :
        """Returns an iterator of ``self``."""
        for Summand in self.Summands() :
            yield Summand


    def __len__ ( self ) -> int :
        """Returns the number of components of ``self``."""
        return len( self.Summands() )


    def Constituent_Parts ( self ) -> list[ Structure ] :
        """Returns the summands of ``self`` as list."""
        return self.Summands()


    def Irreducible_Components ( self ) -> Iterator[ Irreducible_Structure ] :
        """Returns the irreducible components of ``self`` as list."""
        for Summand in self.Summands() :
            for Irreducible_Component in Summand.Irreducible_Components() :
                yield Irreducible_Component


    def Summands ( self ) -> list[ Structure ] :
        """Returns the attribute ``_Summands``."""
        return self._Summands



class Extension_Of_Structures ( Structure ) :

    def __iter__ ( self ) -> Iterator[ Structure ] :
        """Returns an iterator of ``self``."""
        for Part in self.Constituent_Parts() :
            yield Part


    def __len__ ( self ) -> int :
        """Returns the number of constituent parts of ``self``."""
        return 2


    def Constituent_Parts ( self ) -> "Extension_Of_Structures" :
        """Returns the summands of ``self`` as list."""
        return [ self ]


    def Irreducible_Components ( self ) -> Iterator[ Irreducible_Structure ] :
        """Returns the attribute ``_Components``."""
        for Component in [ self.Quotient() , self.Subobject() ] :
            for Irreducible_Component in Component.Irreducible_Components() :
                yield Irreducible_Component


    def Quotient ( self ) -> Structure :
        """Returns the attribute ``_Quotient``."""
        return self._Quotient


    def Subobject ( self ) -> Structure :
        """Returns the attribute ``_Subobject``."""
        return self._Subobject