1class Tone:
  2    """A class that represents a musical tone."""
  3    TONES = ("C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B")
  4
  5    def __init__(self, tone):
  6        if tone not in Tone.TONES or not tone:
  7            raise ValueError("Invalid input for tone")
  8        self.tone = tone
  9
 10    def __str__(self):
 11        return self.tone
 12
 13    def __eq__(self, other):
 14        if isinstance(other, Tone):
 15            return self.tone == other.tone
 16        return False
 17
 18    def __add__(self, other):
 19        if isinstance(other, Interval):
 20            return self.add_interval(other)
 21        if isinstance(other, Tone):
 22            return Chord(self, other)
 23        raise TypeError("Invalid operation")
 24
 25    def __sub__(self, other):
 26        if isinstance(other, Interval):
 27            return self.sub_interval(other)
 28        if isinstance(self, Tone) and isinstance(other, Tone):
 29            return Interval(abs(self.TONES.index(self.tone) - other.TONES.index(other.tone)))
 30        raise TypeError("Invalid operation")
 31
 32    def add_interval(self, other):
 33        """A method that adds an interval to a tone and returns new tone."""
 34        if isinstance(other, Tone):
 35            raise TypeError("Invalid operation")
 36        elif isinstance(self, Tone) and isinstance(other, Interval):
 37            cur_tone_index = self.TONES.index(self.tone)
 38            new_index = (cur_tone_index + other.number_of_semitones) % len(self.TONES)
 39            return Tone(self.TONES[new_index])
 40        raise TypeError("Invalid operation")
 41
 42    def sub_interval(self, other):
 43        """A method that subtracts an interval to a tone and returns new tone."""
 44        if isinstance(self, Tone) and isinstance(other, Interval):
 45            cur_tone_index = self.TONES.index(self.tone)
 46            new_index = abs((cur_tone_index - other.number_of_semitones) % len(self.TONES))
 47            return Tone(self.TONES[new_index])
 48        if isinstance(other, Tone):
 49            raise TypeError("Invalid operation")
 50        raise TypeError("Invalid operation")
 51
 52
 53class Interval:
 54    """A class that represents a musical interval."""
 55    INTERVALS = ("unison", "minor 2nd", "major 2nd", "minor 3rd", "major 3rd", "perfect 4th",
 56                 "diminished 5th", "perfect 5th", "minor 6th", "major 6th", "minor 7th", "major 7th")
 57    INTERVALS_LENGTH = len(INTERVALS)
 58
 59    def __init__(self, number_of_semitones):
 60        if not isinstance(number_of_semitones, int):
 61            raise TypeError("Invalid input for number of semitones")
 62        self.number_of_semitones = number_of_semitones % Interval.INTERVALS_LENGTH
 63
 64    def __str__(self):
 65        return self.INTERVALS[self.number_of_semitones % Interval.INTERVALS_LENGTH]
 66
 67    def __add__(self, other):
 68        if isinstance(self, Interval) and isinstance(other, Interval):
 69            return Interval(self.number_of_semitones + other.number_of_semitones)
 70        raise TypeError("Invalid operation")
 71
 72    def __sub__(self, other):
 73        raise TypeError("Invalid operation")
 74
 75    def __neg__(self):
 76        return Interval(-self.number_of_semitones)
 77
 78
 79class Chord:
 80    """A class that represents a musical chord."""
 81
 82    def __init__(self, *args):
 83        if len(args) == 0:
 84            raise TypeError("Empty chord")
 85        self.root = args[0].tone
 86        self.all_tones = []
 87        for cur_tone in args:
 88            if cur_tone not in self.all_tones:
 89                self.all_tones.append(cur_tone)
 90
 91        if len(self.all_tones) == 1:
 92            raise TypeError("Cannot have a chord made of only 1 unique tone")
 93        
 94        root_index = Tone.TONES.index(self.root)
 95        sorted_all_tones = []
 96        sorted_all_tones.append(Tone.TONES[root_index])
 97
 98        for i in range(1, len(Tone.TONES)):
 99            current_index = (root_index + i) % len(Tone.TONES)
100            current_tone = Tone.TONES[current_index]
101            if Tone(current_tone) in self.all_tones:
102                sorted_all_tones.append(current_tone)
103        self.all_tones = sorted_all_tones
104
105    def __str__(self):
106        return "-".join(str(cur_tone) for cur_tone in self.all_tones)
107
108    def is_minor(self):
109        """A method that checks if there is a tone in the chord that together
110           with the root tone form minor 3rd interval. Returns a boolean."""
111        root_index = Tone.TONES.index(self.root)
112        for tone in self.all_tones:
113            tone_index = Tone.TONES.index(tone)
114            if tone == self.root:
115                continue
116            elif tone_index - root_index == 3:
117                return True
118            elif (root_index - tone_index) % 12 == 9:
119                return True
120        return False
121
122    def is_major(self):
123        """A method that checks if there is a tone in the chord that together
124           with the root tone form major 3rd interval. Returns a boolean."""
125        root_index = Tone.TONES.index(self.root)
126        for tone in self.all_tones:
127            tone_index = Tone.TONES.index(tone)
128            if tone == self.root:
129                continue
130            elif tone_index - root_index == 4:
131                return True
132            elif (root_index - tone_index) % 12 == 9:
133                return True
134        return False
135
136    def is_power_chord(self):
137        """A method that checks if a chord does not contain a tone that, together 
138           with the root, forms a minor 3rd or a major 3rd. Returns a boolean."""
139        if not self.is_major() and not self.is_minor():
140            return True
141        return False
142
143    def __add__(self, other):
144        if isinstance(other, Tone):
145            return Chord(*map(Tone, self.all_tones + [other.tone]))
146        if isinstance(other, Chord):
147            result = []
148            for tone in self.all_tones:
149                result.append(Tone(tone))
150            for tone in other.all_tones:
151                result.append(Tone(tone))
152            return Chord(*result)
153        raise TypeError("Invalid operation")
154
155    def __sub__(self, other):
156        if isinstance(other, Tone):
157            result = []
158            additional_tone = Tone(other.tone)
159            result.append(Tone(other.tone))
160            for tone in self.all_tones:
161                if Tone(tone) == additional_tone:
162                    result.remove(additional_tone)
163                else:
164                    result.append(Tone(tone))
165            if additional_tone in result:
166                raise TypeError(f"Cannot remove tone {Tone(other.tone)} from chord {str(self)}")
167            return Chord(*result)
168        raise TypeError("Invalid operation")
169
170    def transposed(self, interval):
171        """A method that shifts each of its tones by the same interval."""
172        transposed_tones = [Tone(tone) + interval for tone in self.all_tones]
173        return Chord(*transposed_tones)