






"""simple docstring"""






from __future__ import annotations



def    _A     (__a       ,							__a = None       ,							__a = None       ,							__a = False       ,							)					->			tuple[int, float, str]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_ :    Optional[Any]       		=						cipher_alphabet or [chr(lowercase_				) for i in range(97       ,							1_23				)]

    # If the argument is None or the user provided an empty dictionary
    if not frequencies_dict:
        # Frequencies of letters in the english language (how much they show up)
        SCREAMING_SNAKE_CASE_ :    Any       		=						{
            '''a''': 0.0_84_97,
            '''b''': 0.0_14_92,
            '''c''': 0.0_22_02,
            '''d''': 0.0_42_53,
            '''e''': 0.1_11_62,
            '''f''': 0.0_22_28,
            '''g''': 0.0_20_15,
            '''h''': 0.0_60_94,
            '''i''': 0.0_75_46,
            '''j''': 0.0_01_53,
            '''k''': 0.0_12_92,
            '''l''': 0.0_40_25,
            '''m''': 0.0_24_06,
            '''n''': 0.0_67_49,
            '''o''': 0.0_75_07,
            '''p''': 0.0_19_29,
            '''q''': 0.0_00_95,
            '''r''': 0.0_75_87,
            '''s''': 0.0_63_27,
            '''t''': 0.0_93_56,
            '''u''': 0.0_27_58,
            '''v''': 0.0_09_78,
            '''w''': 0.0_25_60,
            '''x''': 0.0_01_50,
            '''y''': 0.0_19_94,
            '''z''': 0.0_00_77,
        }
    else:
        # Custom frequencies dictionary
        SCREAMING_SNAKE_CASE_ :    Optional[Any]       		=						frequencies_dict

    if not case_sensitive:
        SCREAMING_SNAKE_CASE_ :    Tuple       		=						ciphertext.lower()

    # Chi squared statistic values
    SCREAMING_SNAKE_CASE_ :    dict[int, tuple[float, str]]       		=						{}

    # cycle through all of the shifts
    for shift in range(len(lowercase_				)				):
        SCREAMING_SNAKE_CASE_ :    str       		=						''''''

        # decrypt the message with the shift
        for letter in ciphertext:
            try:
                # Try to index the letter in the alphabet
                SCREAMING_SNAKE_CASE_ :    Any       		=						(alphabet_letters.index(letter.lower()				) - shift) % len(
                    lowercase_				)
                decrypted_with_shift += (
                    alphabet_letters[new_key].upper()
                    if case_sensitive and letter.isupper()
                    else alphabet_letters[new_key]
                )
            except ValueError:
                # Append the character if it isn't in the alphabet
                decrypted_with_shift += letter

        SCREAMING_SNAKE_CASE_ :    Optional[Any]       		=						0.0

        # Loop through each letter in the decoded message with the shift
        for letter in decrypted_with_shift:
            if case_sensitive:
                SCREAMING_SNAKE_CASE_ :    int       		=						letter.lower()
                if letter in frequencies:
                    # Get the amount of times the letter occurs in the message
                    SCREAMING_SNAKE_CASE_ :    List[Any]       		=						decrypted_with_shift.lower().count(lowercase_				)

                    # Get the excepcted amount of times the letter should appear based
                    # on letter frequencies
                    SCREAMING_SNAKE_CASE_ :    List[Any]       		=						frequencies[letter] * occurrences

                    # Complete the chi squared statistic formula
                    SCREAMING_SNAKE_CASE_ :    str       		=						((occurrences - expected) ** 2) / expected

                    # Add the margin of error to the total chi squared statistic
                    chi_squared_statistic += chi_letter_value
            else:
                if letter.lower() in frequencies:
                    # Get the amount of times the letter occurs in the message
                    SCREAMING_SNAKE_CASE_ :    Any       		=						decrypted_with_shift.count(lowercase_				)

                    # Get the excepcted amount of times the letter should appear based
                    # on letter frequencies
                    SCREAMING_SNAKE_CASE_ :    int       		=						frequencies[letter] * occurrences

                    # Complete the chi squared statistic formula
                    SCREAMING_SNAKE_CASE_ :    List[str]       		=						((occurrences - expected) ** 2) / expected

                    # Add the margin of error to the total chi squared statistic
                    chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
        SCREAMING_SNAKE_CASE_ :    int       		=						(
            chi_squared_statistic,
            decrypted_with_shift,
        )

    # Get the most likely cipher by finding the cipher with the smallest chi squared
    # statistic
    def chi_squared_statistic_values_sorting_key(__a				) -> tuple[float, str]:
        return chi_squared_statistic_values[key]

    SCREAMING_SNAKE_CASE_ :    int       		=						min(
        lowercase_       ,							key=lowercase_       ,							)

    # Get all the data from the most likely cipher (key, decoded message)
    (
        SCREAMING_SNAKE_CASE_      
    ) :    int       		=						chi_squared_statistic_values[most_likely_cipher]

    # Return the data on the most likely shift
    return (
        most_likely_cipher,
        most_likely_cipher_chi_squared_value,
        decoded_most_likely_cipher,
    )






def     __SCREAMING_SNAKE_CASE							(       lowercase_      ,       lowercase_      )		->     int:




						'''simple docstring'''







						return 1 if input_a == input_a else 0




def     __SCREAMING_SNAKE_CASE							(       )		->     None:




						'''simple docstring'''







						assert xnor_gate(0      ,       0      ) == 1
						assert xnor_gate(0      ,       1      ) == 0
						assert xnor_gate(1      ,       0      ) == 0
						assert xnor_gate(1      ,       1      ) == 1


if __name__ == "__main__":
				print(xnor_gate(0, 0))
				print(xnor_gate(0, 1))
				print(xnor_gate(1, 0))
				print(xnor_gate(1, 1))

