


from __future__ import annotations

from collections.abc import Sequence
from typing import Literal
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->str | Literal[False]:
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     0
   for i in range(len(lowerCAmelCase_   )   ):
      if lista[i] != lista[i]:
         count += 1
         UpperCAmelCase							=     """_"""
   if count > 1:
      return False
   else:
      return "".join(lowerCAmelCase_   )
def   _UpperCamelCase				(						lowerCAmelCase_   )						->list[str]:
   UpperCAmelCase							=     []
   while True:
      UpperCAmelCase							=     ["""$"""] * len(lowerCAmelCase_   )
      UpperCAmelCase							=     []
      for i in range(len(lowerCAmelCase_   )   ):
         for j in range(i + 1  ,						len(lowerCAmelCase_   )   ):
            UpperCAmelCase							=     compare_string(binary[i]  ,						binary[j]   )
            if k is False:
               UpperCAmelCase							=     """*"""
               UpperCAmelCase							=     """*"""
               temp.append("""X"""   )
      for i in range(len(lowerCAmelCase_   )   ):
         if checka[i] == "$":
            pi.append(binary[i]   )
      if len(lowerCAmelCase_   ) == 0:
         return pi
      UpperCAmelCase							=     list(set(lowerCAmelCase_   )   )
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->list[str]:
   UpperCAmelCase							=     []
   for minterm in minterms:
      UpperCAmelCase							=     """"""
      for _ in range(lowerCAmelCase_   ):
         UpperCAmelCase							=     str(minterm % 2   ) + string
         minterm //= 2
      temp.append(lowerCAmelCase_   )
   return temp
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_   )						->bool:
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     list(lowerCAmelCase_   )
   UpperCAmelCase							=     0
   for i in range(len(lowerCAmelCase_   )   ):
      if lista[i] != lista[i]:
         count_n += 1
   return count_n == count
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->list[str]:
   UpperCAmelCase							=     []
   UpperCAmelCase							=     [0] * len(lowerCAmelCase_   )
   for i in range(len(chart[0]   )   ):
      UpperCAmelCase							=     0
      UpperCAmelCase							=     -1
      for j in range(len(lowerCAmelCase_   )   ):
         if chart[j][i] == 1:
            count += 1
            UpperCAmelCase							=     j
      if count == 1:
         UpperCAmelCase							=     1
   for i in range(len(lowerCAmelCase_   )   ):
      if select[i] == 1:
         for j in range(len(chart[0]   )   ):
            if chart[i][j] == 1:
               for k in range(len(lowerCAmelCase_   )   ):
                  UpperCAmelCase							=     0
         temp.append(prime_implicants[i]   )
   while True:
      UpperCAmelCase							=     0
      UpperCAmelCase							=     -1
      UpperCAmelCase							=     0
      for i in range(len(lowerCAmelCase_   )   ):
         UpperCAmelCase							=     chart[i].count(1   )
         if count_n > max_n:
            UpperCAmelCase							=     count_n
            UpperCAmelCase							=     i

      if max_n == 0:
         return temp

      temp.append(prime_implicants[rem]   )

      for i in range(len(chart[0]   )   ):
         if chart[rem][i] == 1:
            for j in range(len(lowerCAmelCase_   )   ):
               UpperCAmelCase							=     0
def   _UpperCamelCase				(						lowerCAmelCase_  ,						lowerCAmelCase_   )						->list[list[int]]:
   UpperCAmelCase							=     [[0 for x in range(len(lowerCAmelCase_   )   )] for x in range(len(lowerCAmelCase_   )   )]
   for i in range(len(lowerCAmelCase_   )   ):
      UpperCAmelCase							=     prime_implicants[i].count("""_"""   )
      for j in range(len(lowerCAmelCase_   )   ):
         if is_for_table(prime_implicants[i]  ,						binary[j]  ,						lowerCAmelCase_   ):
            UpperCAmelCase							=     1

   return chart
def   _UpperCamelCase				(						)						->None:
   UpperCAmelCase							=     int(input("""Enter the no. of variables\n"""   )   )
   UpperCAmelCase							=     [
       float(lowerCAmelCase_   )
       for x in input(
           """Enter the decimal representation of Minterms 'Spaces Separated'\n"""   ).split()
   ]
   UpperCAmelCase							=     decimal_to_binary(lowerCAmelCase_  ,						lowerCAmelCase_   )

   UpperCAmelCase							=     check(lowerCAmelCase_   )
   print("""Prime Implicants are:"""   )
   print(lowerCAmelCase_   )
   UpperCAmelCase							=     prime_implicant_chart(lowerCAmelCase_  ,						lowerCAmelCase_   )

   UpperCAmelCase							=     selection(lowerCAmelCase_  ,						lowerCAmelCase_   )
   print("""Essential Prime Implicants are:"""   )
   print(lowerCAmelCase_   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()







import math






class   __lowercase				:





      def        _lowercase				(		self						:					Union[str, Any]					,       __lowerCamelCase						:					list[list[float]]					,       __lowerCamelCase						:					list[int]       )    ->   int:






         """simple docstring"""







         UpperCAmelCase							=     0.0
         UpperCAmelCase							=     0.0
         for i in range(len(__lowerCamelCase       )       ):
            da += math.pow((sample[i] - weights[0][i])					,       2       )
            da += math.pow((sample[i] - weights[1][i])					,       2       )
            return 0 if da > da else 1
         return 0





      def        _lowercase				(		self						:					List[Any]					,       __lowerCamelCase						:					list[list[int | float]]					,       __lowerCamelCase						:					list[int]					,       __lowerCamelCase						:					int					,       __lowerCamelCase						:					float       )    ->   list[list[int | float]]:






         """simple docstring"""







         for i in range(len(__lowerCamelCase       )       ):
            weights[j][i] += alpha * (sample[i] - weights[j][i])
         return weights

def   _UpperCamelCase				(						)						->None:
   # Training Examples ( m, n )
   UpperCAmelCase							=     [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

   # weight initialization ( n, C )
   UpperCAmelCase							=     [[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

   # training
   UpperCAmelCase							=     SelfOrganizingMap()
   UpperCAmelCase							=     3
   UpperCAmelCase							=     0.5

   for _ in range(lowerCAmelCase_   ):
      for j in range(len(lowerCAmelCase_   )   ):
         # training sample
         UpperCAmelCase							=     training_samples[j]

         # Compute the winning vector
         UpperCAmelCase							=     self_organizing_map.get_winner(lowerCAmelCase_  ,						lowerCAmelCase_   )

         # Update the winning vector
         UpperCAmelCase							=     self_organizing_map.update(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_   )

    # classify test sample
   UpperCAmelCase							=     [0, 0, 0, 1]
   UpperCAmelCase							=     self_organizing_map.get_winner(lowerCAmelCase_  ,						lowerCAmelCase_   )

   # results
   print(F"""Clusters that the test sample belongs to : {winner}"""   )
   print(F"""Weights that have been trained : {weights}"""   )


# running the main() function
if __name__ == "__main__":
 main()



