Alan Smithee steht als Pseudonym für einen fiktiven Regisseur der Filme verantwortet bei denen der eigentliche Regisseur seinen Namen nicht mit dem Werk in Verbindung gebracht haben möchte
Von <num> bis <num> wurde es von der Directors Guild of America DGA für solche Situationen empfohlen seither ist es Thomas Lee Alan Smithee ist jedoch weiterhin in Gebrauch
Alternative Schreibweisen sind unter anderem die Ursprungsvariante Allen Smithee sowie Alan Smythee und Adam Smithee
Auch zwei teilweise asiatisch anmutende Schreibweisen Alan Smi Thee und Sumishii Aran gehören - so die Internet Movie Database - dazu
Geschichte
Entstehung
Das Pseudonym entstand <num> infolge der Arbeiten am Western-Film Death of a Gunfighter deutscher Titel
Frank Patch - Deine Stunden sind gezählt
Regisseur Robert Totten und Hauptdarsteller Richard Widmark gerieten in einen Streit woraufhin Don Siegel als neuer Regisseur eingesetzt wurde
Der Film trug nach Abschluss der Arbeiten noch deutlich Tottens Handschrift der auch mehr Drehtage als Siegel daran gearbeitet hatte weshalb dieser die Nennung seines Namens als Regisseur ablehnte
Totten selbst lehnte aber ebenfalls ab
Als Lösung wurde Allen Smithee als ein möglichst einzigartiger Name gewählt bei der späteren Variante Alan Smithee war das Anagramm The Alias Men vermutlich kein Entstehungsgrund
In den zeitgenössischen Kritiken wurde der Regisseur u a von Roger Ebert mit den Worten gelobt
Aufdeckung und Abkehr
<num> kam die Parodie An Alan Smithee Film Burn Hollywood Burn deutscher Titel
Fahr zur Hölle Hollywood
in die Kinos was das Pseudonym einem größeren Publikum bekannt machte nicht zuletzt weil Arthur Hiller der eigentliche Regisseur des Films selbst seinen Namen zurückzog und analog zum Filmtitel das Pseudonym Alan Smithee benutzte
Der Film gilt als einer der schlechtesten Filme der <num>er Jahre und gewann fünf Goldene Himbeeren
Der Film
Supernova
ist der erste Post-Smithee-Film dort führte ein gewisser Thomas Lee alias Walter Hill die Regie
Verwendung
Die Verwendung dieses oder eines anderen Pseudonyms ist für Mitglieder der DGA streng reglementiert
Ein Regisseur der für einen von ihm gedrehten Film seinen Namen nicht hergeben möchte hat nach Sichtung des fertigen Films drei Tage Zeit anzuzeigen dass er ein Pseudonym verwenden möchte
Der Rat der DGA entscheidet binnen zwei Tagen über das Anliegen
Erhebt die Produktionsfirma Einspruch entscheidet ein Komitee aus Mitgliedern der DGA und der Vereinigung der Film- und Fernsehproduzenten ob der Regisseur ein Pseudonym angeben darf
Über die Beantragung muss der Regisseur Stillschweigen halten ebenso darf er den fertigen Film nicht öffentlich kritisieren wenn die DGA ihm die Verwendung eines Pseudonyms zugesteht Ein Antrag des Regisseurs auf Pseudonymisierung kann abgelehnt werden so durfte Tony Kaye den Namen Smithee bei dem Film
American History X
nicht einsetzen obwohl er den Antrag stellte
Auch bei nicht-US-amerikanischen Produktionen wird der Name verwendet wie etwa beim Pilotfilm der Fernsehserie
Schulmädchen
<num> sendete die ARD am <num> und <num> August den zweiteiligen TV-Film Paparazzo
Auch in diesem Werk erscheint anstatt des eigentlichen Regisseurs Stephan Wagner Alan Smithee im Abspann
Regisseure die das Pseudonym benutzt haben
Don Siegel und Robert Totten für
Frank Patch - Deine Stunden sind gezählt
David Lynch für die dreistündige Fernsehfassung von
Der Wüstenplanet
Chris Christensen The Omega Imperative
Gianni Bozzacchi für I Love NY
Stuart Rosenberg für Lets Get Harry
Richard C Sarafian für
Starfire
Dennis Hopper für
Catchfire
Arthur Hiller für
Fahr zur Hölle Hollywood
Rick Rosenthal Die Vögel II - Die Rückkehr
Kevin Yagher
Hellraiser IV - Bloodline
Der Pilotfilm der Serie
MacGyver
und die fünfte Folge der ersten Staffel führen einen Alan Smithee als Regisseur
Auf der TV-Serien-Seite TV Rage wird Jerrold Freedman als Regisseur des Pilotfilms angegeben
Der Regisseur der fünften Folge ist unbekannt
Zu den Drehbuchautoren die das Pseudonym benutzt haben gehören Sam Raimi und Ivan Raimi die das Drehbuch zu Die total beknackte Nuß als Alan Smithee Jr und Alan Smithee Sr schrieben
Auch in Computerspielen wird dieses Pseudonym angegeben Im Abspann des Ego-Shooters Marine Sharpshooter IV aus dem Jahr <num> wird als Art Director des Spiels Alan Smithee genannt
<num> produzierte die New Yorker Performance-Kompanie Big Dance Theater Alan Smithee Directed this Play das im August des Jahres auch in Berlin bei Tanz im August aufgeführt wurde
Literatur
Jeremy Braddock Stephen Hock Hrsg Directed by Allen Smithee Foreword by Andrew Sarris
University of Minnesota Press Minneapolis London <num> ISBN <num>-<num>-<num>-X
Weblinks
Artikel über Smithee von ABC Online englisch Der Mann der niemals lebte Spiegel Online einestages Alan Smithee lebt DRadio Wissen
Einzelnachweise
latimescom
zuletzt geprüft am <num> April <num> Eigener Eintrag für
in der IMDb
in der Internet Movie Database Siehe zu diesen Regelungen Artikel <num> Abschnitt <num>-<num> des
PDF <num> kB der DGA von <num> abgerufen am <num> April <num> httpeinestagesspiegeldeexternalShowTopicAlbumBackgrounda<num>l<num>l<num>FhtmlfeaturedEntry Alan Smithee ist schuld in Frankfurter Allgemeine Sonntagszeitung vom <num> August <num> Seite <num>
Actinium ist ein radioaktives chemisches Element mit dem Elementsymbol Ac und der Ordnungszahl <num> Im Periodensystem der Elemente steht es in der <num> IUPAC-Gruppe der Scandiumgruppe
Das Element ist ein Metall und gehört zur <num> Periode d-Block
Es ist der Namensgeber der Gruppe der Actinoide der ihm folgenden <num> Elemente
Geschichte
DateiPeriodensystem Mendelejewsjpg
Das Actinium wurde im Jahr <num> von dem französischen Chemiker André-Louis Debierne entdeckt der es aus Pechblende isolierte und ihm zunächst Ähnlichkeiten mit dem Titan
oder dem Thorium
zuschrieb seine Bezeichnung leitete er wegen der Radioaktivität von griechisch ἀκτίς aktís Strahl ab Friedrich Giesel entdeckte das Element unabhängig davon im Jahr <num> und beschrieb eine Ähnlichkeit zum Lanthan er gab ihm den Namen Emanium eine Bildung zu lateinisch emano ausfließen ebenfalls mit Bezug zur abgegebenen Strahlung Nachdem Actinium und Emanium im Jahre <num> als identisch erkannt worden waren wurde Debiernes Namensgebung der Vorzug gegeben da er es zuerst entdeckt hatte
Die Geschichte der Entdeckung wurde in Publikationen von <num> und später im Jahr <num> immer noch als fraglich beschrieben
Sie zeigen dass die Publikationen von <num> einerseits und die von <num> und <num> andererseits Widersprüche aufweisen
Gewinnung und Darstellung
Da in Uranerzen nur wenig Actinium vorhanden ist spielt diese Quelle keine Rolle für die Gewinnung
Technisch wird das Isotop <num>Ac durch Bestrahlung von <num>Ra mit Neutronen in Kernreaktoren hergestellt
Die Zeitangaben sind Halbwertszeiten
Durch den schnellen Zerfall des Actiniums waren stets nur geringe Mengen verfügbar
Die erste künstliche Herstellung von Actinium wurde im Argonne National Laboratory in Chicago durchgeführt
Eigenschaften
Physikalische Eigenschaften
Das Metall ist silberweiß glänzend und relativ weich Aufgrund seiner starken Radioaktivität leuchtet Actinium im Dunkeln in einem hellblauen Licht
Actinium ist das namensgebende Element der Actinoiden ähnlich wie Lanthan für die Lanthanoiden
Die Gruppe der Elemente zeigt deutlichere Unterschiede als die Lanthanoide daher dauerte es bis <num> bis Glenn T Seaborg die wichtigsten Änderungen zum Periodensystem von Mendelejew vorschlagen konnte die Einführung der Actinoide
Chemische Eigenschaften
Es ist sehr reaktionsfähig und wird von Luft und Wasser angegriffen überzieht sich aber mit einer Schicht von Actiniumoxid wodurch es vor weiterer Oxidation geschützt ist Das Ac<num>-Ion ist farblos
Das chemische Verhalten von Actinium ähnelt sehr dem Lanthan
Actinium ist in allen zehn bekannten Verbindungen dreiwertig
Isotope
Bekannt sind <num> Isotope wovon nur zwei natürlich vorkommen
Das langlebigste Isotop <num>Ac Halbwertszeit <num> Jahre hat zwei Zerfallskanäle es ist ein Alpha- und Beta-Strahler
<num>Ac ist ein Zerfallsprodukt des Uranisotops <num>U und kommt zu einem kleinen Teil in Uranerzen vor
Daraus lassen sich wägbare Mengen <num>Ac gewinnen die somit ein verhältnismäßig einfaches Studium dieses Elementes ermöglichen
Da sich unter den radioaktiven Zerfallsprodukten einige Gammastrahler befinden sind aber aufwändige Strahlenschutzvorkehrungen nötig
Verwendung
Actinium wird zur Erzeugung von Neutronen eingesetzt die bei Aktivierungsanalysen eine Rolle spielen
Außerdem wird es für die thermoionische Energieumwandlung genutzt
Beim dualen Zerfall des <num>Ac geht der größte Teil unter Emission von Beta-Teilchen in das Thorium isotop <num>Th aber ca <num>
zerfällt durch Alpha-Emission zu Francium <num>Fr
Eine Lösung von <num>Ac ist daher als Quelle für das kurzlebige <num>Fr verwendbar
Letzteres kann dann regelmäßig abgetrennt und untersucht werden
Sicherheitshinweise
Einstufungen nach der CLP-Verordnung liegen nicht vor weil diese nur die chemische Gefährlichkeit umfassen und eine völlig untergeordnete Rolle gegenüber den auf der Radioaktivität beruhenden Gefahren spielen
Auch Letzteres gilt nur wenn es sich um eine dafür relevante Stoffmenge handelt
Verbindungen
Nur eine geringe Anzahl von Actiniumverbindungen ist bekannt
Mit Ausnahme von AcPO<num> sind sie alle den entsprechenden Lanthanverbindungen ähnlich und enthalten Actinium in der Oxidationsstufe <num> Insbesondere unterscheiden sich die Gitterkonstanten der jeweiligen Lanthan- und Actinium-Verbindungen nur in wenigen Prozent
Oxide
ActiniumIII-oxid Ac<num>O<num> kann durch Erhitzen des Hydroxids bei <num> C oder des Oxalats bei <num> C im Vakuum erhalten werden
Das Kristallgitter ist isotyp mit den Oxiden der meisten dreiwertigen Seltenerdmetalle
Halogenide
ActiniumIII-fluorid AcF<num> kann entweder in Lösung oder durch Feststoffreaktion dargestellt werden
Im ersten Fall gibt man bei Raumtemperatur Flusssäure zu einer Ac<num>-Lösung und fällt das Produkt aus
im anderen Fall wird Actinium-Metall mit Fluorwasserstoff bei <num> C in einer Platinapparatur behandelt
ActiniumIII-chlorid AcCl<num> wird durch Umsetzung von Actiniumhydroxid oder -oxalat mit Tetrachlormethan bei Temperaturen oberhalb von <num> C erhalten
Die Reaktion von Aluminiumbromid und ActiniumIII-oxid führt zum ActiniumIII-bromid AcBr<num> und Behandlung mit feuchtem Ammoniak bei <num> C führt zum Oxibromid AcOBr
Weitere Verbindungen
Gibt man Natriumdihydrogenphosphat NaH<num>PO<num> zu einer Lösung von Actinium in Salzsäure erhält man weiß gefärbtes Actiniumphosphat AcPO<num>
<num> H<num>O ein Erhitzen von ActiniumIII-oxalat mit Schwefelwasserstoff bei <num> C für ein paar Minuten führt zu schwarzem ActiniumIII-sulfid Ac<num>S<num>
Literatur
Harold W Kirby Lester R Morss Actinium in Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements Springer Dordrecht <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> doi<num><num>-<num>-<num>-<num>_<num>
Weblinks
Einzelnachweise André-Louis Debierne Sur une nouvelle matière radio-active in
Comptes rendus
<num> <num> S <num>-<num> André-Louis Debierne Sur un nouvel élément radio-actif
lactinium in
Comptes rendus
<num> <num> S <num>-<num>
N A Figurowski Die Entdeckung der chemischen Elemente und der Ursprung ihrer Namen in deutscher Übersetzung von Leo KorniljewErnst Lemke Moskau <num> ISBN <num>-<num>-<num>-<num> S <num>Friedrich Oskar Giesel Ueber Radium und radioactive Stoffe in
Berichte der Deutschen Chemischen Gesellschaft
<num> <num> <num> S <num>-<num> doi<num>cber<num>Friedrich Oskar Giesel Ueber den Emanationskörper Emanium in
Berichte der Deutschen Chemischen Gesellschaft
<num> <num> <num> S <num>-<num> doi<num>cber<num>Friedrich Oskar Giesel Ueber Emanium in
Berichte der Deutschen Chemischen Gesellschaft
<num> <num> <num> S <num>-<num> doi<num>cber<num>H W Kirby The Discovery of Actinium in
Isis
<num> <num> <num> S <num>-<num> J P Adloff The centenary of a controversial discovery actinium in Radiochim Acta
<num> <num> S <num> doi<num>ract<num><num>-<num> Frederick Seitz David Turnbull Solid state physics advances in research and applications Academic Press <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> Glenn T Seaborg The Transuranium Elements in
Science
<num> <num> Nr <num> S <num>-<num> doi<num>science<num><num> PMID <num>Joseph G Stites Murrell L Salutsky Bob D Stone Preparation of Actinium Metal in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num>J J Katz W M Manning Chemistry of the Actinide Elements in
Annual Review of Nuclear Science
<num> <num> S <num>-<num> doi<num>annurevns<num><num>Sherman Fried French Hagemann W H Zachariasen The Preparation and Identification of Some Pure Actinium Compounds in
J Am Chem Soc
<num> <num> S <num>-<num> doi<num>ja<num>a<num>
DateiAng Lee - <num>eme Festival de Venise Mostra <num>jpg Ang Lee
<num> Oktober <num> in Chaozhou Landkreis Pingtung Taiwan ist ein taiwanisch-US-amerikanischer Filmregisseur Drehbuchautor und Produzent
Er ist als vielfach ausgezeichneter Regisseur bekannt für so unterschiedliche Filme wie
Eat Drink Man Woman
die Jane-Austen-Adaption
Sinn und Sinnlichkeit
und den Martial Arts-Film
Tiger and Dragon
Für seine Filme
Brokeback Mountain
<num> und
Life of Pi Schiffbruch mit Tiger
<num> wurde er jeweils mit dem Oscar in der Kategorie Beste Regie ausgezeichnet
Leben
Ang Lee wurde <num> in Taiwan geboren
Seine Eltern Emigranten aus China lernten sich in Taiwan kennen Lee ist ihr ältester Sohn
Die Großeltern väterlicher- und mütterlicherseits sind im Zuge der kommunistischen Revolution in China ums Leben gekommen
Da sein Vater als Lehrer häufiger die Arbeitsstelle wechselte wuchs Ang Lee in verschiedenen Städten Taiwans auf
Entgegen den Wünschen seiner Eltern wie sein Vater eine klassische akademische Laufbahn einzuschlagen interessierte sich Lee für das Schauspiel und absolvierte mit ihrem Einverständnis zunächst ein Theater- und Filmstudium in Taipeh
Im Anschluss daran ging er <num> in die USA um an der Universität von Illinois in Urbana-Champaign Theaterwissenschaft und -regie zu studieren
Nach dem Erwerb seines BA in Illinois verlegte er sich ganz auf das Studium der Film- und Theaterproduktion an der Universität von New York das er <num> mit einem Master abschloss
Danach entschloss er sich mit seiner ebenfalls aus Taiwan stammenden Ehefrau zusammen in den USA zu bleiben
Sein Interesse verschob sich trotz erster Erfahrungen mit dem Super-<num>-Film in Taiwan erst spät ganz auf Filmregie und -produktion - auch weil Lee seinen Berufswunsch seiner Familie und insbesondere seinem Vater gegenüber lange Zeit nicht eingestehen wollte Nach dem Studium konnte er zunächst keine eigenen Projekte umsetzen
Erst ab <num> als er seinen ersten Langfilm fertigstellte zeichnete sich eine kontinuierliche Karriere als Regisseur ab
Als seine bisher größte Erfolge - sowohl beim Publikum als auch bei der Kritik - gelten das Martial Arts-Drama
Tiger and Dragon
mit einer pan-asiatischen Starbesetzung und der Post-Western-Liebesfilm
Brokeback Mountain
mit Heath Ledger und Jake Gyllenhaal
Für Letzteren bekam Lee <num> als erster asiatisch-stämmiger und nicht-weißer Regisseur den Oscar für die beste Regie
Außerdem wurden Lees Filme neben vielen weiteren Preisen mit mittlerweile zwei Goldenen Bären der Berlinale und zwei Goldenen Löwen der Filmfestspiele von Venedig ausgezeichnet
Lee ist seit <num> mit der Mikrobiologin Jane Lin verheiratet
Sie leben in White Plains Westchester County im Bundesstaat New York
Aus der Ehe stammen die Söhne Haan
<num> und Mason
<num>
Ang Lee besitzt die US-amerikanische Staatsbürgerschaft
Filmisches Werk
Nach seinen ersten Filmerfahrungen in Taiwan setzte sich Lee erst wieder während seines Studiums in den USA ernsthaft mit dem Filmemachen auseinander
Im Rahmen seines Studiums in New York drehte er einige Kurzfilme und wirkte unter anderem beim Abschlussdreh seines Studienkollegen Spike Lee als Regieassistent mit
Sein eigener Abschlussfilm Fine Line gewann <num> zwei Preise beim renommierten Filmfest seiner Universität Erst <num> gelang es ihm nach dem Gewinn eines hochdotierten Drehbuchwettbewerbs in Taiwan den ersten einer Reihe von drei Filmen zu drehen die west-östliche Konflikte taiwanischer Familien zum Thema haben
<num>-<num> Die Father-Knows-Best-Trilogie
Diese ersten drei Langfilme die Lee realisieren konnte werden im Allgemeinen unter dem Begriff Father Knows Best gefasst Diese Bezeichnung geht auf die wiederkehrende Figur des chinesischen Familienoberhaupts gespielt jeweils vom taiwanischen Schauspieler Sihung Lung zurück
Die drei Filme thematisieren wie später noch öfter bei Ang Lee familiäre Probleme die aus dem Konflikt zwischen Selbstbestimmung und Tradition zwischen Innen und Außen zwischen Ost und West sowie zwischen den Generationen herrühren
Die Filme sind allesamt US-amerikanisch-taiwanische Koproduktionen
Anders als bei allen bislang folgenden Projekten handelt es sich bei den ersten Filmen Lees nicht um Adaptionen sondern um Filme nach von ihm selbst geschriebenen Originaldrehbüchern
Der erste Film
Schiebende Hände
<num> handelt vom Einzug eines chinesischen Vaters bei seinem erwachsenen Sohn und der US-amerikanischen Schwiegertochter in New York und den interkulturellen Problemen die in der neuen Wohngemeinschaft entstehen
Dies war die erste Zusammenarbeit zwischen Lee und dem Drehbuchautor und Produzenten James Schamus - seitdem bildeten die beiden bei jedem Film Lees eine enge Arbeitsgemeinschaft
Wie in den beiden folgenden Filmen schrieben sie auch gemeinsam das Drehbuch In allen weiteren Filmen Lees mit Ausnahme des Kurzfilms
The Hire Chosen
hat Schamus seither entscheidende Funktionen ausgeübt
Auch die regelmäßige Zusammenarbeit mit dem Filmeditor Tim Squyres nahm in Lees Erstling ihren Anfang
Mit Ausnahme des Erfolgsfilms Brokeback Mountain von <num> hat Squires jeden Film den Ang Lee gedreht hat geschnitten
Nach dem Erfolg seines Erstlings konnte Lee als Nächstes
Das Hochzeitsbankett
<num> drehen eine Komödie über die fingierte Eheschließung eines homosexuellen Exil-Taiwaners in den USA
Erneut taucht hier die Figur des strengen aber weisen Familienoberhaupts auf
Hatte Schiebende Hände zunächst vor allem in Taiwan für Aufmerksamkeit und Preise gesorgt wurde mit dem zweiten Langfilm Lees auch Europa auf den aufstrebenden Regisseur aufmerksam Der Film erhielt bei der Berlinale <num> den Goldenen Bären als Bester fremdsprachiger Film und war zudem für einen Oscar nominiert
Er gilt darüber hinaus als einer der profitabelsten Low-Budget-Filme des Jahres <num>
Mit nur einer Million US-Dollar Produktionskosten erzielte er ein Einspielergebnis von über <num> Millionen US-Dollar
Sihung Lung ist auch im letzten Teil der Trilogie
Eat Drink Man Woman
<num> die kongeniale Verkörperung des chinesischen Familienoberhaupts das Zentrum dieser Maskeraden in denen es darum geht ein altes Gesicht zu wahren und dann zu lernen es zu verlieren um ein neues lebenstauglicheres zu gewinnen Dieses Mal ist er der verwitwete Vater dreier Töchter die ihr Leben und ihre Lieben auf unterschiedliche Art angehen und dabei ebenfalls innerfamiliäre Konflikte klären müssen
Eat Drink Man Woman wurde anders als seine Vorgänger in Taipeh gedreht
Im Mittelpunkt des Films stehen der Titel deutet es an die Liebe und das Essen
Ang Lee privat ein passionierter Koch legte hierbei besonders großen Wert auf die kulinarische Komponente als Stilmittel und konzipierte die Hauptfigur des älteren Witwers als berühmten Koch
<num>-<num> Dreimal anglo-amerikanische Geschichte
Mit dem Angebot der Produzentin Lindsay Doran die von der britischen Schauspielerin Emma Thompson verfasste Adaption des Romans
Verstand und Gefühl
von Jane Austen in Großbritannien zu drehen eröffnete sich Lee eine lange ersehnte neue Perspektive jenseits asiatisch geprägter Stoffe
In einer neuen Trilogie setzt er sich mit unterschiedlichen Kulturen auseinander
Sinn und Sinnlichkeit
ist die Verfilmung des Romans der englischen Schriftstellerin Jane Austen
Der Eissturm
spielt in den USA der <num>er Jahre
Ride with the Devil
ist im Amerikanischen Bürgerkrieg angesiedelt
<num>-heute Pendeln zwischen West und Ost
Tiger and Dragon
sowie
Hulk
sind sehr unterschiedliche Action-Filme
Mit Tiger and Dragon gewann Lee zwei Golden Globes
Das Werk wurde außerdem mit vier Academy Awards Oscars prämiert darunter der Trophäe für den besten fremdsprachigen Film
Für diesen Film wurde er <num> auch mit einem Chlotrudis Award ausgezeichnet seinen zweiten Chlotrudis erhielt er <num> für Brokeback Mountain
Für
Brokeback Mountain
wurde Lee mit einer Vielzahl von Filmpreisen geehrt darunter der Oscar für die beste Regie der Goldene Löwe der Filmfestspiele von Venedig sowie die Auszeichnung der Hollywood Foreign Press Association als bester Regisseur des Jahres
<num> verfilmte er mit
Gefahr und Begierde
eine Kurzgeschichte von Eileen Chang
Der Thriller spielt zur Zeit des Zweiten Weltkriegs in Shanghai und handelt von einer jungen chinesischen Agentin gespielt von Tang Wei die beauftragt wird einen hochrangigen Verräter Tony Leung Chiu Wai zu liquidieren
Lees erste chinesischsprachige Spielfilmproduktion seit Tiger and Dragon war <num> im offiziellen Wettbewerb der <num> Filmfestspiele von Venedig vertreten und brachte ihm erneut den Goldenen Löwen ein
Im selben Jahr wurde Gefahr und Begierde als offizieller taiwanischer Beitrag für die Nominierung um den besten fremdsprachigen Film bei der Oscar-Verleihung <num> ausgewählt später aber auf Empfehlung der Academy of Motion Picture Arts and Sciences wieder zurückgezogen und durch Chen Huai-Ens Lian xi qu
ersetzt
Ende Februar <num> wurde bekannt gegeben dass Lee die Jury der <num> Filmfestspiele von Venedig leiten werde Zwei Monate später erhielt er für seine Komödie Taking Woodstock eine Einladung in den Wettbewerb der <num> Internationalen Filmfestspiele von Cannes
<num> wurde er in die Wettbewerbsjury des <num> Filmfestivals von Cannes berufen
Stil
Ang Lee ist ein international anerkannter und erfolgreicher Regisseur und gilt als einer der vielseitigsten Filmemacher der letzten Jahre
Häufig behandelt Lee in seinen Filmen das Thema Familie auf eine Art und Weise die autobiographische Züge seines eigenen Lebens trägt
Er lässt seine Umgebung ganz bewusst auf sich einwirken und bringt diese in seine Filme ein
Kennzeichnend für die meisten seiner Filme ist eine wenig geradlinige Erzählstruktur die die Charaktere und die Geschichte aus verschiedenen Blickwinkeln darstellt
Er verknüpft die Konflikte des menschlichen Lebens mit traditionellen und innovativen Stilelementen
Für Ang Lee sind die klassisch-soliden Erzählstrukturen zu langweilig daher kombiniert er verschiedene Genres und Epochen
Er selbst sagte einmal
Filmografie
DateiAng Lee <num>ème Festival de Venise Mostrajpg
<num> Schiebende Hände Pushing Hands Tui shou
<num> Das Hochzeitsbankett The Wedding Banquet Xi yan
<num> Eat Drink Man Woman Yin shi nan nu
<num> Sinn und Sinnlichkeit Sense and Sensibility
<num> Der Eissturm The Icestorm
<num> Wer mit dem Teufel reitet Ride with the Devil
<num> Tiger and Dragon auch Crouching Tiger Hidden Dragon Wo hu cang long
<num> The Hire Chosen Kurzwerbefilm für eine Automarke
<num> Hulk
<num> Brokeback Mountain
<num> Gefahr und Begierde Sè jiè
<num> Taking Woodstock
<num> Life of Pi Schiffbruch mit Tiger
<num> Die irre Heldentour des Billy Lynn Billy Lynns Long Halftime Walk
<num> Gemini Man
Auszeichnungen Auswahl
Oscarverleihung
<num> Auszeichnung in der Kategorie Bester fremdsprachiger Film für Tiger
Dragon
<num> Nominierung in der Kategorie
Beste Regie
für Tiger
Dragon
<num> Nominierung in der Kategorie
Bester Film
für Tiger
Dragon
<num> Auszeichnung in der Kategorie
Beste Regie
für Brokeback Mountain
<num> Auszeichnung in der Kategorie
Beste Regie
für Life of Pi Schiffbruch mit Tiger
<num> Nominierung in der Kategorie
Bester Film
für Life of Pi Schiffbruch mit Tiger
Golden Globe Award
<num> Nominierung in der Kategorie
Beste Regie
für Sinn und Sinnlichkeit
<num> Auszeichnung in der Kategorie
Beste Regie
für Tiger
Dragon
<num> Auszeichnung in der Kategorie
Beste Regie
für Brokeback Mountain
<num> Nominierung in der Kategorie
Beste Regie
für Life of Pi Schiffbruch mit Tiger
Directors Guild of America Award
<num> Nominierung in der Kategorie Beste Spielfilmregie für Sinn und Sinnlichkeit
<num> Auszeichnung in der Kategorie Beste Spielfilmregie für Tiger
Dragon
<num> Auszeichnung in der Kategorie Beste Spielfilmregie für Brokeback Mountain
<num> Nominierung in der Kategorie Beste Spielfilmregie für Life of Pi Schiffbruch mit Tiger
Weitere Auszeichnungen
<num> Goldener Bär der Berliner Filmfestspiele für Das Hochzeitsbankett
<num> Golden Horse Beste Regie für Das Hochzeitsbankett
<num> Goldener Bär der Berliner Filmfestspiele für Sinn und Sinnlichkeit
<num> Bundesfilmpreis für den besten ausländischen Film mit Sinn und Sinnlichkeit
<num> Golden Horse Bester Film für Tiger and Dragon
<num> Hong Kong Film Award für Tiger and Dragon
<num> Aufnahme in die American Academy of Arts and Sciences
<num> Goldener Löwe des Filmfestivals in Venedig für Brokeback Mountain
<num> Golden Horse Beste Regie für Gefahr und Begierde
<num> Goldener Löwe des Filmfestivals in Venedig für Gefahr und Begierde
Siehe auch
Taiwanischer Film
US-amerikanischer Film
Literatur
Tanja Hanhart Redaktorin Ang Lee und sein Kino
Poesie im Grossformat
In du <num> Feb
<num> ISBN <num>-<num>-<num>-<num>-<num>
Thomas Koebner Artikel Ang Lee In Ders
Hrsg Filmregisseure
Biographien Werkbeschreibungen Filmographien
Mit <num> Abbildungen
<num> aktualisierte und erweiterte Auflage
Reclam Stuttgart <num> <num> Aufl <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
Qin Hu Das Kino von Ang Lee - Von der chinesischen Philosophie Kunstauffassung und Kultur zu filmästhetischen Aspekten Gardez
Verlag <num>
Michael Pekler Andreas Ungerböck Ang Lee und seine Filme Schüren Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Isabell Gössele Das Kino des Ang Lee - Im Atem des verborgenen Drachen Tectum Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Weblinks
Biografie auf film-zeitde
Ang Lee Biografie bei WHOS WHO
In
Spiegel Online
<num> Oktober <num> Interview
Der Subtext des Western Interview auf criticde
Ralph Geisenhanslüke
In Zeit <num> Januar <num> Interview
Andreas Kilb
In FAZ <num> Oktober <num>
Einzelnachweise
Michael Pekler Andreas Ungerböck Ang Lee und seine Filme Schüren Marburg <num> Christoph Schneider Chronik von Leben und Werk In Ang Lee und sein Kino Poesie im Grossformat In du <num> Feb <num> S <num>-<num> Michael Pekler und Andreas Ungerböck merken dazu ironisch an dass man die Trilogie besser mit Father Thinks He Knows Best titulieren könne da die Patriarchen keineswegs für alles eine Lösung haben vgl Michael Pekler Andreas Ungerböck Ang Lee und seine Filme Schüren Marburg <num> S <num> Für Das Hochzeitsbankett zeichnete zusätzlich Neil Peng für Eat Drink Man Woman Hui-Ling Wang verantwortlich Isabell Gössele Das Kino des Ang Lee - Im Atem des verborgenen Drachen Tectum Marburg <num> S <num>Pekler Ungerböck <num> S <num> Christoph Schneider Chronik von Leben und Werk In Ang Lee und sein Kino Poesie im Grossformat In du <num> Feb <num> S <num>Pekler Ungerböck <num> S <num> f Douglas Tseng Shorter version of Lust to be shown here In The Straits Times Singapore <num> September <num> LIFE - LIFE BUZZ
In
fr-online
<num> Februar <num> abgerufen am <num> Juni <num> Schiffbruch mit Zuschauer in
FAZ
<num> Dezember <num> S <num>
Anschluss ist in der Soziologie ein Fachbegriff aus der Systemtheorie von Niklas Luhmann und bezeichnet die in einer sozialen Begegnung auf eine Selektion der anderen Seite folgende selbst gewählte Selektion
Diese Selektionen beziehen sich aufeinander
Die Anschlussfähigkeit ist die Kapazität von Systemen zu gewährleisten dass sich an die Selektionen eines Systems weitere anschließen können
Alle sozialen Systeme reproduzieren sich über Kommunikation z B
Wirtschaftssystem oder Politik oder Handlungen Medizin und Erziehungssystem
Dies gelingt nur wenn die einzelnen Einheiten aneinander anschlussfähig sind was durch einen systemspezifischen Code geleistet wird der als zentrale Logik Leitunterscheidung aller Kommunikation zugrunde liegt und sie als systemzugehörig erkennbar macht
Im Wirtschaftssystem beispielsweise sorgt der Code zahlennicht zahlen dafür dass die Kommunikationen sich auf sich selbst beziehen und sich selbst reproduzieren können also dass auf jede Zahlung eine neue erfolgt
Dies funktioniert über das generalisierte Kommunikationsmedium Geld das die letzte Zahlung mit der jetzigen verknüpft
Würde das Geld nicht mehr akzeptiert folgt der Zahlung keine weitere Zahlung mehr und das System hätte seine Anschlussfähigkeit verloren
Die Anschlussfähigkeit innerhalb eines Systems wird als Selbstreferenz bezeichnet im Gegensatz zum fremdreferentiellen Bezug auf die Umwelt Welt andere Systeme
Den Begriff hat Luhmann auf eine Anregung eines Bielefelder Kollegen des Philosophen Jürgen Frese entwickelt
Frese zeigte in einem Sektionsreferat des Achten Deutschen Kongresses für Philosophie in Heidelberg <num> gedruckt <num> mit dem Titel Sprechen als Metapher für Handeln dass es fruchtbar ist von den dominanten Handlungsmodellen Arbeit und Konsum abzurücken und ergänzend Sprechen als Modell für Handeln zu nutzen
Frese schreibt Die wichtigste Errungenschaft die die Sprachmetapher für die Aufhellung des nicht-sprachlichen Handelns einbringt ist ihre Leistung Reihenbildung erklärbar zu machen
Fassen wir Satz und Handlung zum neutralen und an andere Philosopheme anschließbaren Begriff des Aktes zusammen so können wir
sagen Der Sinn eines Aktes ist das als eine bestimmte Situation gegebene Ensemble der Möglichkeiten an diesen Akt weitere Akte anzuschließen d h
der Sinn eines Aktes ist die Mannigfaltigkeit der Anschließbarkeiten die er eröffnet Diese Idee wurde von Luhmann aufgegriffen und im Rahmen seiner Systemtheorie weiterentwickelt
Frese selbst baute sie im Rahmen seiner Lehre von den Formularen weiter aus
Literatur
Niklas Luhmann Soziale Systeme
Grundriß einer allgemeinen Theorie
Suhrkamp Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num>
Jürgen Frese
Sprechen als Metapher für Handeln In Hans-Georg Gadamer Das Problem der Sprache
Achter Deutscher Kongress für Philosophie
Heidelberg <num> Fink Verlag München <num> S <num>-<num>
Jürgen Frese Prozesse im Handlungsfeld Klaus Boer Verlag München <num> ISBN <num>-<num>-<num>-<num>
Einzelnachweise Frese <num> S <num>fFrese <num>
Die Aussagenlogik ist ein Teilgebiet der Logik das sich mit Aussagen und deren Verknüpfung durch Junktoren befasst ausgehend von strukturlosen Elementaraussagen Atomen denen ein Wahrheitswert zugeordnet wird
In der klassischen Aussagenlogik wird jeder Aussage genau einer der zwei Wahrheitswerte wahr und falsch zugeordnet
Der Wahrheitswert einer zusammengesetzten Aussage lässt sich ohne zusätzliche Informationen aus den Wahrheitswerten ihrer Teilaussagen bestimmen
Geschichte
Historisch geht die Aussagenlogik zurück bis zu Aristoteles der erstmals aussagenlogische Grundsätze diskutierte nämlich in seiner Metaphysik den Satz vom Widerspruch und den Satz vom ausgeschlossenen Dritten und der in seiner ersten Analytik den indirekten Beweis thematisierte
Die zweiwertige aussagenlogische Semantik entwickelten etwas später die megarischen Philosophen Diodoros Kronos und Philon
Die Aussagensemantik und -axiomatik kombinierte der Stoiker Chrysippos von Soli der den ersten aussagenlogischen Kalkül formulierte
Die Weiterentwicklung der Aussagenlogik der Stoa durch das Mittelalter wird oft übersehen Eine erste vollständige und entscheidbare Formalisierung für aussagenlogische Tautologien - allerdings noch nicht für das aussagenlogische Schließen - schuf George Boole <num> mit seinem algebraischen Logikkalkül
Den ersten aussagenlogischen Kalkül mit Schlussregeln formulierte Gottlob Frege im Rahmen seiner Begriffsschrift <num>
Er war die Vorlage für den Aussagenkalkül von Bertrand Russell <num> der sich später durchsetzte s u
Abgrenzung zu anderen Logiken
Da in der heutigen Mathematik die klassische Aussagenlogik maßgeblich wurde wird in diesem Artikel dieser moderne Haupttypus der Aussagenlogik behandelt
Allgemein ist die klassische Logik durch zwei Eigenschaften charakterisiert
Jede Aussage hat einen von genau zwei Wahrheitswerten meist falsch oder wahr Prinzip der Zweiwertigkeit oder Bivalenzprinzip
Der Wahrheitswert jeder zusammengesetzten Aussage ist eindeutig durch die Wahrheitswerte ihrer Teilaussagen bestimmt Prinzip der Extensionalität oder Kompositionalität siehe Extensionalitätsprinzip
Das Prinzip der Zweiwertigkeit wird oft mit dem Satz vom ausgeschlossenen Dritten verwechselt
Die klassische Aussagenlogik ist jenes Gebiet der klassischen Logik das die innere Struktur von Sätzen Aussagen daraufhin untersucht aus welchen anderen Sätzen Teilsätzen sie zusammengesetzt sind und wie diese Teilsätze miteinander verknüpft sind
Die innere Struktur von Sätzen die ihrerseits nicht in weitere Teilsätze zerlegt werden können wird von der Aussagenlogik nicht betrachtet
Ein Beispiel Die Aussage Alle Katzen sind Hunde und die Erde ist eine Scheibe ist mit dem Bindewort und aus den beiden kürzeren Aussagen Alle Katzen sind Hunde und Die Erde ist eine Scheibe zusammengesetzt
Diese beiden Aussagen lassen sich ihrerseits nicht mehr in weitere Aussagen zerlegen sind aus aussagenlogischer Sicht also elementar oder atomar
Andere auf die Aussagenlogik aufbauende logische Systeme betrachten die innere Struktur solcher atomaren Aussagen ein wichtiges Beispiel ist die Prädikatenlogik
In Abgrenzung zur klassischen Logik entstehen nichtklassische Logiksysteme wenn man das Prinzip der Zweiwertigkeit das Prinzip der Extensionalität oder sogar beide Prinzipien aufhebt
Nichtklassische Logiken die durch die Aufhebung des Prinzips der Zweiwertigkeit entstehen heißen mehrwertige Logik
Die Zahl der Wahrheitswerte in diesem Falle üblicher Pseudowahrheitswerte kann dabei endlich sein z B
dreiwertige Logik ist aber oft auch unendlich z B
Fuzzy-Logik
Hingegen verwenden Logiken die durch die Aufhebung der Extensionalität entstehen Junktoren Konnektive bei denen sich der Wahrheitswert des zusammengesetzten Satzes nicht mehr eindeutig aus dem Wahrheitswert seiner Teile bestimmen lässt
Ein Beispiel für nichtextensionale Logik ist die Modallogik die die einstelligen nichtextensionalen Operatoren es ist notwendig dass und es ist möglich dass einführt
Logische Systeme stehen innerhalb der Logik nicht in einem Konkurrenzverhältnis um Wahrheit oder Richtigkeit
Die Frage welches logische System für einen bestimmten Zweck genutzt werden soll ist eher eine pragmatische
Oft werden logische Systeme und logische Fragestellungen mit außerlogischen Fragen verwechselt oder vermischt z B
mit der metaphysischen Frage welches logische System richtig sei d h
die Wirklichkeit beschreibe
Zu dieser Frage gibt es unterschiedliche Standpunkte einschließlich des positivistischen Standpunkts dass diese Frage sinnlos sei
Diese Fragen fallen aber in andere Gebiete z B
Philosophie Wissenschaftstheorie und Sprachwissenschaft
Wenn in diesem Artikel die klassische Aussagenlogik behandelt wird so ist das also nicht als metaphysische Festlegung zu verstehen oder gar als Behauptung dass alle Aussagen wahr oder falsch sind Es ist lediglich so dass die klassische Aussagenlogik einfach nur solche Aussagen behandelt die wahr oder falsch sind
Das ist eine große formale Vereinfachung die dieses System relativ leicht erlernbar sein lässt
Braucht man aus metaphysischen oder pragmatischen Gründen mehr als zwei Wahrheitswerte kann die klassische Aussagenlogik als Ausgangspunkt dienen um ein geeignetes logisches System aufzustellen
Umgangssprachliche Einleitung
Einfache Aussage Elementaraussage
Eine Aussage A ist ein Satz der entweder wahr w wahr true <num> oder nicht wahr f falsch false <num> ist
Das gilt sowohl für einfache als auch für verknüpfte Aussagen
Halbwahrheiten gibt es nicht
Eine Aussage kann sowohl der gewöhnlichen Sprache entstammen als auch der Sprache der Mathematik
Eine Elementaraussage ist eine Aussage die keine aussagenlogischen Verknüpfungen nicht und oder wenn
dann genau dann wenn enthält
Beispiele für Elementaraussagen
München ist <num> km von Hamburg entfernt
<num> ist durch <num> teilbar
Eintracht Frankfurt wird in der nächsten Saison deutscher Fußballmeister
Alle Autos sind grün
ist offensichtlich wahr
dagegen ist falsch
muss man zunächst prüfen bevor man entscheiden kann ob
wahr oder falsch ist
Ob
wahr ist kann man derzeit nicht entscheiden
Das wird sich erst am Ende der nächsten Fußballsaison herausstellen
In der klassischen Aussagenlogik ist eine Aussage entweder wahr oder nicht wahr auch wenn man den Wahrheitsgehalt nicht kennt
Das ist zum Beispiel bei den ungelösten mathematischen Problemen der Fall
Anmerkung
ist eine All-Aussage die Struktur solcher Aussagen ist Gegenstand der Prädikatenlogik
Im Sinne der Aussagenlogik ist es eine Elementaraussage
Verneinte Aussage - Negation
Die Verneinung bzw Negation auch Satzverneinung äußere Verneinung kontradiktorisches Gegenteil einer Aussage A ist diejenige Aussage A die genau dann wahr ist wenn A falsch ist und die genau dann falsch ist wenn A wahr ist
Einfacher Die Verneinung einer Aussage A dreht den Wahrheitswert von A in sein Gegenteil um
Man erhält die Verneinung einer Aussage A immer dadurch dass man ihr die Formulierung Es ist nicht der Fall dass voranstellt
Zwar lässt sich ein natürlichsprachlicher Satz auch verneinen indem man das Wort nicht oder eine andere negative Formulierung an geeigneter Stelle einfügt - es ist aber nicht immer ganz einfach zu erkennen welche Formulierung zu verwenden und an welcher Stelle einzufügen ist
Formal schreibt man für nicht A in der gebräuchlichsten Notation Schreibweise A auf Englisch und in der Schaltalgebra auch NOT A gelegentlich auch A
Wir verneinen die obigen Beispiele
Es ist nicht der Fall dass München <num> km von Hamburg entfernt ist
Es ist nicht der Fall dass <num> durch <num> teilbar ist
Es ist nicht der Fall dass Eintracht Frankfurt in der nächsten Saison deutscher Fußballmeister wird
Es ist nicht der Fall dass alle Autos grün sind
Es kann durchaus auch grüne Autos geben aber es gibt mindestens ein Auto das nicht grün ist
Allgemein gilt für die Verneinung
Wenn eine Aussage
wahr ist ist die Verneinung
falsch
Wenn eine Aussage
falsch ist ist die Verneinung
wahr
Eine Aussage
kann nicht gleichzeitig wahr und falsch sein
Die Aussagen
und
können nicht gleichzeitig wahr sein
Und-verknüpfte Aussagen - Konjunktion
Eine Konjunktion ist eine aus zwei Aussagen zusammengesetzte Aussage die die Wahrheit all ihrer Teilaussagen behauptet
Umgangssprachlich verbindet man zwei Aussagen A und B durch das Bindewort und zu einer Konjunktion A und B in der logischen Sprache verwendet man meist das Zeichen
Schreibweise
gelegentlich auch das kaufmännische Und den Ampersand
Sprechweise A und B
Schreibweise
auf Englisch und in der Schaltalgebra auch A AND B
Die Aussage
ist immer dann wahr wenn sowohl A als auch B jeweils wahr sind
Andernfalls ist
falsch nämlich dann wenn entweder A oder B oder beide Aussagen falsch sind
Beispiele für eine Und-Verknüpfung
A <num> ist durch <num> teilbar B <num> ist eine Quadratzahl
Diese Teilaussagen und ihre Negationen werden nun durch
miteinander verknüpft
<num> ist durch <num> teilbar und <num> ist eine Quadratzahl
<num> ist nicht durch <num> teilbar und <num> ist eine Quadratzahl
<num> ist durch <num> teilbar und <num> ist keine Quadratzahl
<num> ist nicht durch <num> teilbar und <num> ist keine Quadratzahl
Nur
ist wahr weil
wahr ist und auch
wahr ist
ist falsch weil
falsch ist
ist falsch weil
falsch ist
ist falsch weil sowohl
als auch
falsch ist
Nichtausschließendes Oder - Disjunktion
Eine Disjunktion ist eine zusammengesetzte Aussage die behauptet dass mindestens eine ihrer Teilaussagen wahr ist
Die Disjunktion in diesem Sinn wird auch nichtausschließendes Oder genannt
Aber Achtung Die Bezeichnung Disjunktion wurde und wird oft auch für das ausschließende Oder entweder
oder verwendet - man denke an das Konzept der disjunkten Mengen
Einige Autoren verwenden daher für das Nichtausschließende Oder den Begriff Adjunktion Das Formelzeichen
stammt von dem lateinischen Wort vel was auf deutsch oder bedeutet
Sprechweise A oder B genauer A oder B oder beide häufig in juristischen oder medizinischen Texten A undoder B
Schreibweise
auf Englisch und in der Schaltalgebra auch A OR B
Die Aussage
ist immer dann wahr wenn mindestens eine der Teilaussagen A oder B wahr ist bzw wenn beide Teilaussagen wahr sind
Andernfalls ist
falsch nämlich dann wenn sowohl A als auch B falsch sind
Beispiel für eine Oder-Verknüpfung
A <num> ist durch <num> teilbar
B <num> ist eine Quadratzahl
Diese Teilaussagen und ihre Negationen werden nun durch
miteinander verknüpft
<num> ist durch <num> teilbar oder <num> ist eine Quadratzahl
<num> ist nicht durch <num> teilbar oder <num> ist eine Quadratzahl
<num> ist durch <num> teilbar oder <num> ist keine Quadratzahl
<num> ist nicht durch <num> teilbar oder <num> ist keine Quadratzahl
ist wahr weil sowohl
als auch
wahr sind
ist wahr weil
wahr ist
ist wahr weil
wahr ist Nur
ist falsch weil sowohl
als auch
falsch sind
Materiale Implikation
Die materiale Implikation auch Konditional oder Subjunktion genannt drückt die hinreichende Bedingung aus Sie sagt dass die Wahrheit des einen Satzes eine hinreichende Bedingung für die Wahrheit des anderen Satzes ist
Man schreibt
oder auch
und liest
A ist eine hinreichende Bedingung für B
Schon wenn A dann B
A setzt voraus dass B
B ist eine notwendige Bedingung für A Dass B genau dann eine notwendige Bedingung für A ist wenn A eine hinreichende Bedingung für B ist ist eine auf den ersten Blick überraschende und vielleicht kontraintuitive jedoch zutreffende Feststellung
Das Unterkapitel Hinreichende und notwendige Bedingung bemüht sich diesen Zusammenhang sichtbarer zu machen
A impliziert B
Nur wenn B dann A
oder auch nur
Wenn A dann B
In einem Konditional nennt man A das Antezedens B das Konsequens oder Sukzedens
Beispiele
Dass es regnet ist eine hinreichende Bedingung dafür dass die Straße nass ist
Schon wenn es regnet ist die Straße nass
Wenn es regnet ist die Straße nass
Nur wenn die Straße nass ist kann es regnen
Wenn Person x einen Wagen der Marke y hat hat x ein Auto
Wenn eine Zahl n durch <num> teilbar ist dann ist die Zahl n durch <num> teilbar
Die Lesart wenn
dann ist insofern problematisch als mit dem natürlichsprachlichen wenn
dann vor allem inhaltliche Zusammenhänge wie Kausalität oder zeitliche Nähe ausgedrückt werden
All das macht die materiale Implikation nicht sie nennt nur den formalen Zusammenhang Dass es regnet ist eine hinreichende Bedingung dafür dass die Straße nass ist Zur Frage warum das eine hinreichende Bedingung ist - ob auf Grund eines kausalen Zusammenhangs oder auch nur rein zufällig - nimmt die materiale Implikation nicht Stellung
Als Umkehrschluss bezeichnet man den Schluss von
auf
Für die Beispiele bedeutet das
Wenn die Straße nicht nass ist regnet es nicht
Wenn Person x kein Auto hat dann hat x keinen Wagen der Marke y
Wenn die Zahl n nicht durch <num> teilbar ist dann ist n nicht durch <num> teilbar
Umgangssprachlich lässt man sich gelegentlich zu weiteren - falschen - Aussagen verleiten
Weil es nicht regnete kann die Straße nicht nass sein Diese Folgerung ist falsch da die Straße auch aus anderen Gründen nass werden kann Rohrbruch Übung der Feuerwehr
x hat keinen Wagen der Marke y also hat x kein Auto Falsch denn er könnte ja einen Wagen der Marke z haben
n ist nicht durch <num> teilbar also ist n auch nicht durch <num> teilbar Auch diese Folgerung ist falsch
Die Zahl <num> ist nicht durch <num> teilbar und sehr wohl durch <num>
Das bedeutet Wenn die Folgerung
wahr ist dann erhält man aus der Aussage A keine Aussage über B B kann wahr oder falsch sein
Ex falso sequitur quodlibet - Aus Falschem folgt Beliebiges
Die Implikation ist ein wichtiges Mittel in der Mathematik
Die meisten mathematischen Beweise verwenden das Konzept der Implikation
Bikonditional
Das Bikonditional oft auch objektsprachliche Äquivalenz oder materiale Äquivalenz genannt drückt die hinreichende und notwendige Bedingung aus sagt also dass eine Aussage A genau dann zutrifft wenn eine Aussage B zutrifft
Man schreibt
und liest
A ist genau dann der Fall wenn B der Fall ist
A genau dann wenn B
A ist äquivalent zu B
A ist dann und nur dann der Fall wenn B der Fall ist
Auch beim Bikonditional wird eine rein formale Aussage getroffen die nichts über einen allfälligen inhaltlichen Zusammenhang von A und B aussagt
Statt
zu sagen kann man auch sagen dass A eine hinreichende Bedingung für B und dass B eine hinreichende Bedingung für A ist also
Tatsächlich sind diese beiden Aussagen logisch äquivalent
Beispiel
Die natürliche Zahl n ist genau dann durch <num> teilbar wenn n durch <num> und durch <num> teilbar ist Wenn n durch <num> teilbar ist dann folgt daraus dass n durch <num> und durch <num> teilbar ist
Umgekehrt gilt aber auch Wenn n durch <num> und durch <num> teilbar ist dann ist n durch <num> teilbar
Heute ist genau dann Dienstag wenn morgen Mittwoch ist
Das Bikonditional als zusammengesetzte Aussage innerhalb der logischen Sprache siehe Objektsprache wird oft mit dem Konzept der logischen Äquivalenz verwechselt oder vermischt
Die logische Äquivalenz ist eine metasprachliche meist natürlichsprachlich formulierte Eigenschaft zweier Aussagen der logischen Sprache
Ein Zusammenhang zwischen logischer Äquivalenz und Bikonditional besteht nur insofern als das Metatheorem gilt dass ein Bikonditional
genau dann eine Tautologie ist wenn die beiden Aussagen A und B logisch äquivalent sind
Ausschließendes Oder
Das ausschließende Oder Kontravalenz oder Antivalenz entweder A oder B besagt dass genau eine der beiden von ihm verknüpften Aussagen wahr ist
Entsprechend ist ein ausschließendes Oder nicht nur dann falsch wenn sowohl A als auch B falsch sind sondern auch wenn beide wahr sind
Einige Autoren verwenden für das Ausschließende Oder den Begriff Alternative
Obwohl das ausschließende Oder ein Konzept ist mit dem man in der natürlichen Sprache immer wieder zu tun hat wird es in den meisten logischen Sprachen nicht als eigenständiger Junktor eingeführt
Stattdessen wird das ausschließende Oder zum Beispiel als verneintes Bikonditional ausgedrückt also als
Große Bedeutung genießt das ausschließende Oder hingegen in der Schaltalgebra wo es meist als XOR eXclusive OR aufgeschrieben wird
Verneinung einer verknüpften Aussage De Morgansche Gesetze
Verneinung einer Konjunktion
Die Verneinung der Konjunktion A und B in der logischen Schreibweise
lautet Es ist nicht der Fall dass A und B zutreffen in der logischen Schreibweise
Diese ist logisch äquivalent mit der Aussage A ist nicht der Fall oder B ist nicht der Fall oder beides in logischer Schreibweise
Ein Beispiel
Wenn man die Aussage
Es regnet und die Erde ist eine Scheibe
verneinen möchte dann kann man entweder sagen
Es ist nicht der Fall dass es regnet und die Erde eine Scheibe ist
oder man sagt
Es regnet nicht oder die Erde ist keine Scheibe oder beides
In der Schaltalgebra wird sehr oft der Junktor NAND verwendet wobei A NAND B denselben Wahrheitswertverlauf hat wie der Ausdruck
Verneinung einer Disjunktion
Die Verneinung der Disjunktion A oder B oder beides in der logischen Schreibweise
lautet Es ist nicht der Fall dass A oder B zutrifft in logischer Schreibweise
Diese ist logisch äquivalent mit der Aussage A ist nicht der Fall und B ist nicht der Fall in logischer Schreibweise
Ein Beispiel
Wenn man die Aussage
Die Erde ist eine Scheibe oder die Erde ist ein Würfel
verneinen möchte so sagt man
Es ist nicht der Fall dass die Erde eine Scheibe ist oder dass die Erde ein Würfel ist
Nach dem Gesetz von De Morgan kann man nun aber auch sagen
Die Erde ist keine Scheibe und die Erde ist kein Würfel
oder in schönerem Deutsch
Die Erde ist weder eine Scheibe noch ein Würfel
In der Schaltalgebra wird das Konnektiv NOR verwendet das denselben Wahrheitswertverlauf hat wie die Aussage
Hinreichende und notwendige Bedingung
Dieser Abschnitt soll den zunächst oft als kontraintuitiv empfundenen Zusammenhang zwischen hinreichender und notwendiger Bedingung wie er im Abschnitt über die materiale Implikation angesprochen wurde wiederaufgreifen und näher ausführen
Betrachten wir noch einmal die materiale Implikation
Man sagt A ist hinreichend für B Schon wenn A der Fall ist ist auch B der Fall
Umgekehrt kann man aber auch sagen B ist notwendig für A Ohne B kann A nicht erfüllt sein
Wie kommt dieser Zusammenhang zustande
Wir wissen dass die Wahrheit von A die Wahrheit von B nach sich zieht denn A ist ja hinreichende Bedingung für B Somit ist es einfach nicht möglich dass A eintritt ohne dass B damit ebenfalls eintreten würde B ist also gezwungenermaßen der Fall wenn A der Fall ist
B ist notwendig für A
Dieser Zusammenhang ist in Wahrheit also ziemlich einfach Hauptgrund dafür dass er anfangs oft als kontraintuitiv empfunden wird ist wahrscheinlich die Schwierigkeit zwischen den vielen Bedeutungen des umgangssprachlichen wenn
dann einerseits und der rein formalen hinreichenden und notwendigen Bedingung andererseits strikt zu trennen
Mit dem umgangssprachlichen wenn
dann möchte man fast immer einen inhaltlichen kausalen oder auch temporalen Zusammenhang zwischen Antecedens und Konsequens ausdrücken Regen verursacht Straßennässe Zuerst fällt der Regen erst nachher wird die Straße nass Wenn man die hinreichende Bedingung in diesem Sinn missversteht dann ist es klar dass die in umgekehrter Reihenfolge formulierte notwendige Bedingung Nur wenn die Straße nass ist regnet es seltsam aussieht Regen verursacht doch Straßennässe
Wie kann daraus je gefolgert werden dass Straßennässe Regen verursacht
All dies sagt die materiale Implikation aber nicht aus
A ist eine hinreichende Bedingung für B meint schlicht dass wenn die Aussage A wahr ist auch die Aussage B wahr ist - zeitlos und zusammenhanglos nicht etwa später oder weil
Analog sagt die notwendige Bedingung B ist eine notwendige Bedingung für A lediglich das aus dass B wahr ist sofern A es ist
Genau das ist aber die Definition des Konditionals A
B
Formaler Zugang
Einleitung
Spätestens beim lauten Lesen von Sätzen wie
Die Aussage
ist genau dann wahr wenn die Aussagen A und B wahr sind
wird der selbstbewusste Laie verlangen dass ihm erklärt wird was das soll
Die Antwort des Logikers Es soll versucht werden Sicherheit in die Regeln des logischen Schließens zu bringen
Seit den Sophisten ist dem Abendland klar dass scheinbar zwingende Schlüsse zu offensichtlich absurden Ergebnissen führen können
Immer wieder wurden Paradoxien formuliert und von großen Denkern als Herausforderung empfunden
Logiker versuchen deshalb die Regeln des Argumentierens so streng wie möglich zu fassen
Das einleitende Beispiel macht klar dass dazu eine Trennung der Sprachebenen unerlässlich ist Die formale Aussage AB soll dadurch erklärt werden dass auf einer metasprachlichen Ebene über die Aussage A wie auch über die Aussage B geredet wird
Ein Versuch dies durchzuführen besteht darin die Aussagenlogik als formales System konkret als Kalkül eine bestimmte Art eines formalen Systems zu definieren
Die Begriffe wahr und falsch kommen in diesem System zunächst überhaupt nicht vor
Stattdessen werden Axiome gesetzt die einfach als Zeichenketten angesehen werden aus denen weitere ableitbare Zeichenketten aufgrund von bestimmten Schlussregeln hergeleitet werden
Das Ziel dabei ist einerseits dass in einem formalen System nur Zeichenketten Sätze hergeleitet werden können die bei einer plausiblen Interpretation auch wahr sind
Andererseits sollen alle Sätze die als wahr interpretierbar sind auch hergeleitet werden können
Das erste ist die Forderung nach Korrektheit das zweite die nach Vollständigkeit des formalen Systems beide Eigenschaften sind unter Kalkül Der Begriff Kalkül in der Logik beschrieben
Für die klassische Aussagenlogik mit der wir es hier zu tun haben gibt es Kalküle formale Systeme die sowohl korrekt als auch vollständig sind
Für komplexere logische Systeme z B
Mengenlehre ist es aber unmöglich einen vollständigen Kalkül aufzustellen der auch korrekt ist - diese Erkenntnis wurde <num> von Kurt Gödel bewiesen Gödelscher Unvollständigkeitssatz
Syntax
Es gibt viele verschiedene Möglichkeiten die Syntax Grammatik einer logischen Sprache formal zu definieren meist geschieht das im Rahmen eines Kalküls
Die folgende Definition ist daher nur als Beispiel dafür zu verstehen wie ein Kalkül für die klassische Aussagenlogik aussehen kann
Weitere Beispiele für konkrete Kalküle finden sich unter Baumkalkül Begriffsschrift Systeme natürlichen Schließens Sequenzenkalkül oder Resolutionskalkül
Ein weiterer axiomatischer Kalkül ist als Beispiel im Artikel Hilbert-Kalkül angegeben ein graphischer Kalkül im Artikel Existential Graphs
Bausteine der aussagenlogischen Sprache
Als Bausteine der aussagenlogischen Sprache sollen Satzbuchstaben atomare Formeln Satzkonstanten Junktoren und Gliederungszeichen verwendet werden
Satzbuchstaben sollen die Zeichen P<num> P<num> P<num>
sein
Junktoren sollen die Zeichen
und
sein
Als Gliederungszeichen sollen die runden Klammern dienen
Formal lässt sich das z B
auf folgende Weise ausdrücken
Sei V die abzählbar unendliche Menge der atomaren Formeln Satzbuchstaben
V
Pn
n
N <num> N <num> Menge der natürlichen Zahlen inkl <num> d h
V
P<num> P<num> P<num> P<num>
Sei J die Menge der Junktoren und Gliederungszeichen
J
Das
Alphabet
der logischen Sprache sei die Menge V
J also die Vereinigungsmenge von atomaren Formeln Junktoren und Gliederungszeichen
Formationsregeln
Die Formationsregeln legen fest wie man aus den Bausteinen der aussagenlogischen Sprache Sätze Formeln bilden kann
Hier sollen aussagenlogische Formeln als Worte über dem Alphabet der logischen Sprache also über V
J wie folgt induktiv definiert werden
Alle atomaren Formeln F
V d h
alle Satzbuchstaben sind Formeln
Ist F eine Formel so ist auch F eine FormelDiese Formel heißt
Negation
von F
Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
G eine FormelDiese Formel heißt
Konjunktion
von F und G
Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
G eine FormelDiese Formel heißt
Disjunktion
von F und G
Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
G eine FormelDiese Formel heißt
materiale Implikation
oder Konditional von F und G
Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
G eine FormelDiese Formel heißt
Bikonditional
von F und G
Nichts anderes ist eine aussagenlogische Formel
Schlussregeln
Schlussregeln sind allgemein Transformationsregeln Umformungsregeln die auf bestehende Formeln angewandt werden und aus ihnen neue Formeln erzeugen
Wenn man einen Kalkül für ein logisches System aufstellt dann wählt man die Transformationsregeln so dass sie aus bestehenden Formeln solche Formeln erzeugen die aus den Ausgangsformeln semantisch folgen - deshalb die Bezeichnung Schlussregel eine Schlussfolgerung ziehen
Innerhalb der Syntax sind die Schlussregeln allerdings rein formale Transformationsregeln denen für sich keinerlei inhaltliche Bedeutung zukommt
An konkreten Schlussregeln sollen hier nur zwei angegeben werden Der Modus ponendo ponens und die Substitutionsregel
Modus ponendo ponens
Aus einem Satz der Form
und einem Satz der Form
darf man auf einen Satz der Form
schließen dabei sind
und
Platzhalter für beliebige Formeln
Zum Beispiel darf man nach dieser Schlussregel aus Wenn Regen die Straße benetzt dann ist der Straßenbelag regennass und aus Regen benetzt die Straße schließen auf Der Straßenbelag ist regennass
Substitutionsregel Ersetzungsregel
In einem Satz dürfen alle Vorkommnisse eines beliebigen Atoms z B
P durch einen beliebig komplexen Satz z B
ersetzt werden
Es müssen dabei aber auch wirklich alle Vorkommnisse des gewählten Atoms ersetzt werden und sie müssen auch wirklich alle durch denselben Satz ersetzt werden
Zum Beispiel darf mittels der Substitutionsregel aus
auf
geschlossen werden
Man sagt P werde durch
ersetzt bzw
werde für P substituiert eingesetzt
Axiome
Axiome sind ausgezeichnete im Sinn von hervorgehobene Formeln der aussagenlogischen Sprache
Die Auszeichnung besteht darin dass sie innerhalb eines Beweises oder einer Herleitung siehe unten ohne weitere Rechtfertigung verwendet werden
Pragmatisch wählt man solche Formeln als Axiome die semantisch gesehen Tautologien sind also immer zutreffen und die dabei helfen Beweise zu verkürzen
Innerhalb der Syntax sind die Axiome allerdings rein formale Objekte denen keinerlei inhaltliche Bedeutung oder Rechtfertigung zukommt
Axiome sind im Allgemeinen optional d h
ein Kalkül kann auch ganz ohne Axiome auskommen wenn er ausreichend viele bzw mächtige Schlussregeln hat
Axiomfreie Kalküle sind zum Beispiel die Systeme natürlichen Schließens oder Baumkalküle
Hier soll exemplarisch ein axiomatischer Kalkül gezeigt werden und zwar Russells Aussagenkalkül aus seiner Typentheorie <num> den er <num> in die Principia Mathematica übernahm Dieser Kalkül umfasst die folgenden Axiome von denen das vierte redundant d h
nicht unbedingt erforderlich weil aus den anderen Axiomen herleitbar ist
Um aus diesen Axiomen auch solche gültigen Sätze herleiten zu können die andere als die in den Axiomen vorkommende Junktoren enthalten werden diese durch folgende Festlegung auf die vorhandenen Junktoren zurückgeführt
Alternativ zu - wie hier - konkreten Axiomen kann man auch Axiomenschemata angeben in welchem Fall man auch ohne Substitutionsregel auskommt
Interpretiert man die obigen Axiome als Axiomenschemata dann stünde z B
das erste Axiomenschema
für unendlich viele Axiome nämlich alle Ersetzungsinstanzen dieses Schemas
Herleitung und Beweis
Eine Herleitung ist eine Liste von aufsteigend nummerierten Sätzen die mit einer oder mehreren Annahmen den Prämissen der Herleitung oder Axiomen beginnt
Alle auf diese folgenden Sätze sind entweder ebenfalls Axiome bei manchen Kalkülen sind auch weitere Annahmen zulässig oder sind aus einer oder mehreren der vorangehenden Zeilen durch Anwendung von Schlussregeln entstanden
Der letzte Satz in der Liste ist die Konklusion der Herleitung
Eine Herleitung ohne Prämissen heißt Beweis
Oft werden aber die Wörter Herleitung und Beweis synonym gebraucht
Wenn es gelingt aus einer Menge von Annahmen Prämissen Δ eine Konklusion P herzuleiten dann schreibt man auch
Gelingt es einen Satz P ohne die Verwendung von Annahmen herzuleiten zu beweisen dann schreibt man auch
In diesem Fall wird P Theorem genannt
Das Zeichen
geht auf die Begriffsschrift zurück jenes Werk in dem Gottlob Frege <num> die erste Formalisierung der Prädikatenlogik angegeben hat
In der klassischen Aussagenlogik wählt man die Schlussregeln so dass sich mit ihrer Hilfe alle gültigen Argumente und nur gültige Argumente herleiten lassen die Frage der Gültigkeit wird im folgenden Abschnitt Semantik behandelt
Semantik
Außerhalb der Logik bezeichnet Semantik ein Forschungsgebiet das sich mit der Bedeutung von Sprache und deren Teilen befasst
Oft wird auch das Wort Semantik gleichbedeutend mit dem Wort Bedeutung verwendet
Auch innerhalb der Logik geht es bei Semantik um Bedeutung Darum nämlich den Ausdrücken einer formalen Sprache - zum Beispiel der hier behandelten Sprache der Aussagenlogik - eine Bedeutung zuzuordnen
In der Logik wird auch das meist sehr formal unternommen
Im Zentrum der formalen Semantik steht eine Auswertungsfunktion andere Bezeichnungen lauten Bewertungsfunktion Denotationsfunktion Wahrheitswertefunktion die den Formeln der logischen Sprache eine Bedeutung zuordnet
Formal gesprochen ist die Auswertungsfunktion eine Abbildung von der Menge der Formeln der Sprache in die Menge der Wahrheitswerte
Oft wird die Auswertungsfunktion mit dem Großbuchstaben V bezeichnet
In der klassischen Aussagenlogik ist die Auswertungsfunktion sehr einfach Das Prinzip der Zweiwertigkeit fordert dass sie für jede zu bewertende Formel genau einen von genau zwei Wahrheitswerten liefern muss und das Prinzip der Extensionalität fordert dass die Bewertungsfunktion beim Bewerten eines komplexen Satzes nur die Bewertung von dessen Teilsätzen berücksichtigen muss
Jedem Atom also jedem Satzbuchstaben Atom wird durch Festsetzung ein Wahrheitswert zugeordnet
Man sagt Die Atome werden interpretiert
Es wird also z B
festgelegt dass P<num> wahr ist dass P<num> falsch ist und dass P<num> ebenfalls falsch ist
Damit ist der Bewertung der Bausteine der logischen Sprache Genüge getan
Formal ist eine solche Bewertung - Interpretation genannt und oft mit dem Kleinbuchstaben v bezeichnet - eine Funktion im mathematischen Sinn d h
eine Abbildung von der Menge der Atome in die Menge der Wahrheitswerte
Wenn die Auswertungsfunktion V auf ein Atom angewandt wird d h
wenn sie ein Atom bewerten soll liefert sie die Interpretation dieses Atoms im Sinn des obigen Absatzes
Mit anderen Worten sie liefert den Wert den die Bewertung v dem Atom zuordnet
Um die zusammengesetzten Formeln bewerten zu können muss für jeden Junktor definiert werden welchen Wahrheitswert die Bewertungsfunktion für die unterschiedlichen Wahrheitswertkombinationen liefert den seine Argumente annehmen können
In der klassischen Aussagenlogik geschieht das meist mittels Wahrheitstabellen weil es nur überschaubar wenige Möglichkeiten gibt
Der einstellige Junktor
die Negation ist in der klassischen Aussagenlogik so definiert dass er den Wahrheitswert seines Arguments ins Gegenteil umkehrt also verneint Ist die Bewertung einer Formel X wahr dann liefert die Bewertungsfunktion für X falsch wird aber X falsch bewertet dann liefert die Bewertungsfunktion für X wahr
Die Wahrheitstabelle sieht folgendermaßen aus
Die Wahrheitswertverläufe der verwendeten zweistelligen Konnektive sind in der klassischen Aussagenlogik wie folgt definiert
Allgemein gibt es für die klassische Aussagenlogik vier einstellige und sechzehn zweistellige Junktoren
Die hier behandelte logische Sprache beschränkt sich nur deshalb auf die Junktoren
und
weil diese am gebräuchlichsten sind und weil sie auch inhaltlich noch am ehesten aus der Alltagssprache bekannt sind
Aus formaler Sicht ist die einzige Bedingung die man bei der Wahl von Junktoren erfüllen möchte die dass sich mit den gewählten Junktoren auch alle anderen theoretisch möglichen Junktoren ausdrücken lassen man sagt Dass die Menge der gewählten Junktoren funktional vollständig ist
Diese Anforderung ist bei der hier getroffenen Wahl erfüllt
Näheres zur Frage wie viele und welche Junktoren es gibt und wie viele Junktoren man benötigt um funktionale Vollständigkeit zu erreichen ist im Kapitel Junktor beschrieben
Semantische Gültigkeit Tautologien
Semantische Gültigkeit ist eine Eigenschaft von Formeln oder von Argumenten
Ein Argument ist die Behauptung dass aus einigen Aussagen - den Prämissen - eine bestimmte Aussage - die Konklusion - folgt
Eine Formel der aussagenlogischen Sprache heißt genau dann semantisch gültig wenn die Formel unter allen Interpretationen - d h
unter allen Zuordnungen von Wahrheitswerten zu den in ihr vorkommenden Atomen - wahr ist wenn sie sozusagen allgemeingültig ist mit anderen Worten Wenn die Wahrheitstabelle für diese Aussage in jeder Zeile das Ergebnis wahr zeigt
Man nennt semantisch gültige Formeln auch Tautologien und schreibt wenn
eine Tautologie ist formal wie folgt
Ein Argument heißt genau dann semantisch gültig wenn unter der Voraussetzung dass alle Prämissen wahr sind auch die Konklusion wahr ist
In der Formulierung von Gottfried Wilhelm Leibniz Aus Wahrem folgt nur Wahres Diese Definition muss natürlich ebenfalls formal gefasst werden und das geschieht wie folgt Ein Argument ist genau dann semantisch gültig wenn alle Zuordnungen von Wahrheitswerten zu den in Prämissen und Konklusion vorkommenden Atomen unter denen die Bewertungsfunktion für alle Prämissen den Wert wahr liefert auch für die Konklusion den Wert wahr liefert
Um auszudrücken dass aus einer Menge
von Formeln der Prämissenmenge eine Formel
die Konklusion semantisch folgt schreibt man formal wie folgt
Beachte die graphische Ähnlichkeit und die inhaltliche Verschiedenheit zwischen
Kapitel Herleitung und Beweis und
Siehe Semantische Folgerung Die erste Formulierung -
- drückt die syntaktische Gültigkeit des Arguments aus sagt also dass aus den Formeln in
mit den Schlussregeln des gewählten Kalküls die Formel
hergeleitet werden kann
hingegen behauptet die semantische Gültigkeit die in der klassischen Aussagenlogik wie in den vorangegangenen Absätzen als das Leibnizsche Aus Wahrem folgt nur Wahres definiert ist
Wichtige semantische Eigenschaften Erfüllbarkeit Widerlegbarkeit und Unerfüllbarkeit
Neben der Eigenschaft der Gültigkeit Allgemeingültigkeit gibt es einige andere wichtige Eigenschaften Erfüllbarkeit Widerlegbarkeit und Unerfüllbarkeit
Im Gegensatz zur Gültigkeit die Eigenschaft von Formeln oder von Argumenten sein kann sind Erfüllbarkeit Widerlegbarkeit und Unerfüllbarkeit Eigenschaften von Sätzen oder von Satzmengen
Eine Formel heißt erfüllbar wenn es mindestens eine Interpretation der in ihr vorkommenden Atome Satzbuchstaben gibt unter der die Formel wahr ist
Eine Formel heißt widerlegbar wenn es mindestens eine Interpretation der in ihr vorkommenden Atome gibt unter der die Formel falsch ist
Eine Formel heißt unerfüllbar wenn sie unter allen Interpretationen der in ihr vorkommenden Satzbuchstaben falsch ist
Eine Formelmenge heißt erfüllbar wenn alle in ihr enthaltenen Formeln erfüllbar sind
Die Frage ob eine Formel oder eine Formelmenge eine der genannten Eigenschaften hat ist ebenso wie die Frage ob eine Formel allgemeingültig d h
eine Tautologie ist für allgemeine Formeln nicht effizient lösbar Zwar ist die Wahrheitstafel ein Entscheidungsverfahren für jede dieser Fragen doch umfasst eine Wahrheitstafel für eine Aussage bzw eine Aussagemenge in n Atomen
Zeilen das Wahrheitstafelverfahren ist nichts anderes als ein Brute-Force-Verfahren
Jede dieser Fragestellungen kann auf die Frage zurückgeführt werden ob eine bestimmte Formel erfüllbar ist
Eine Formel
ist genau dann eine Tautologie wenn
unerfüllbar ist
Eine Formel
ist genau dann widerlegbar wenn
erfüllbar ist
Die Frage ob eine Aussage erfüllbar ist wird Erfüllbarkeitsproblem oder SAT-Problem nach dem englischen Wort für Erfüllbarkeit satisfiability genannt
Das SAT-Problem spielt eine wichtige Rolle in der theoretischen Informatik und Komplexitätstheorie
Das Erfüllbarkeitsproblem für allgemeine beliebige Formeln ist NP-vollständig d h
unter der Voraussetzung dass P ungleich NP nicht in polynomialer Laufzeit lösbar
Für bestimmte echte Teilmengen der Formeln der aussagenlogischen Sprache ist das SAT-Problem dennoch schneller d h
in polynomial beschränkter Rechenzeit lösbar
Eine solche Teilmenge sind die Horn-Formeln das sind Konjunktionen von Disjunktionen deren Disjunkte verneinte oder unverneinte Atome sind wobei innerhalb einer solchen Disjunktion allerdings höchstens ein Atom unverneint sein darf
Algebraische Sicht
Wenn man die Semantik betrachtet die hier für die klassische Aussagenlogik aufgestellt wurde dann erkennt man gewisse Gesetzmäßigkeiten
Wird z B
die Auswertungsfunktion auf eine Aussage der Form X
W angewendet wobei W eine beliebige wahre Aussage sein soll dann stellt man fest dass die Auswertungsfunktion für X
W immer den Wahrheitswert wahr liefert wenn VXwahr ist das heißt VXWVX Von der Struktur her gleichwertige Gesetzmäßigkeiten gelten auch in anderen Semantiken auch in solchen die für ganz andere nichtlogische Systeme aufgestellt werden
Für die Arithmetik gilt z B dass die dortige Bewertungsfunktion hier VArithmetik genannt für einen Ausdruck der Form X
Y immer den Wert von X liefert sofern der Wert von Y null ist VArithmetikXYVArithmetikX wenn VArithmetikY
null ist
Eine formale Wissenschaft die solche strukturellen Gesetzmäßigkeiten untersucht ist die abstrakte Algebra meist Teilgebiet der Mathematik aber auch der Informatik
In der abstrakten Algebra wird zum Beispiel untersucht für welche Verknüpfungen es ein neutrales Element gibt d h
ein Element N das für eine Verknüpfung op dazu führt dass für beliebiges X gilt X op N
X So würde man aus algebraischer Sicht sagen dass es für die klassische aussagenlogische Konjunktion genau ein neutrales Element gibt nämlich wahr und dass es für die Addition in der Arithmetik ebenfalls genau ein neutrales Element gibt nämlich die Zahl Null
Nur am Rande sei erwähnt dass es auch für andere Junktoren neutrale Elemente gibt das neutrale Element für die Disjunktion ist falsch VX
F
VX wenn VFfalsch ist
Die formale Algebra betrachtet formale Semantiken rein nach ihren strukturellen Eigenschaften
Sind diese identisch dann besteht zwischen ihnen aus algebraischer Sicht kein Unterschied
Aus algebraischer Sicht genauer Aus Sicht der formalen Algebra ist die Semantik für die klassische Aussagenlogik eine zweiwertige Boolesche Algebra
Andere formale Systeme deren Semantiken jeweils eine Boolesche Algebra bilden sind die Schaltalgebra und die elementare Mengenlehre
Aus algebraischer Sicht besteht daher zwischen diesen Disziplinen kein Unterschied
Normalformen
Jede aussagenlogische Formel lässt sich in eine äquivalente Formel in konjunktiver Normalform und eine äquivalente Formel in disjunktiver Normalform umformen
Metatheorie
In der Metatheorie werden die Eigenschaften von logischen Systemen untersucht Das logische System ist in der Metatheorie der Untersuchungsgegenstand
Eine metatheoretische Fragestellung ist zum Beispiel die ob in einem Kalkül ein Widerspruch hergeleitet werden kann
Der vorliegende Abschnitt soll einige wichtige metatheoretische Fragestellungen aus dem Blickwinkel der Aussagenlogik betrachten
Konsistenz
Ein Kalkül wird genau dann konsistent genannt wenn es unmöglich ist mit Hilfe seiner Axiome und Regeln einen Widerspruch herzuleiten d h
eine Aussage der Form P
P z B
Hugo ist groß und Hugo ist nicht groß Für einen Kalkül der in der Aussagenlogik verwendet werden soll ist das eine Mindestanforderung
Ist es in einem Kalkül möglich einen Widerspruch herzuleiten dann wird der Kalkül inkonsistent genannt
Es gibt formale Systeme in denen solch ein Widerspruch hergeleitet werden kann die aber durchaus sinnvoll sind
Für solche Systeme wird ein anderer Konsistenzbegriff verwendet Ein Kalkül ist konsistent wenn in ihm nicht alle Formeln herleitbar sind siehe parakonsistente Logik
Es lässt sich leicht zeigen dass für die klassische Logik die beiden Konsistenzbegriffe zusammenfallen In der klassischen Logik lässt sich aus einem Widerspruch jeder beliebige Satz herleiten dieser Sachverhalt wird Ex falso quodlibet genannt d h
wenn ein klassischer Kalkül auch nur einen Widerspruch herleiten könnte also im ersten Sinn inkonsistent wäre dann könnte er jede Aussage herleiten wäre also im zweiten Sinn inkonsistent
Wenn umgekehrt ein Kalkül inkonsistent im zweiten Sinn ist also in ihm jede Aussage herleitbar ist dann ist insbesondere auch jeder Widerspruch herleitbar und ist er auch inkonsistent im ersten Sinn
Korrektheit
Ein Kalkül heißt genau dann korrekt semantisch korrekt wenn in ihm nur solche Formeln hergeleitet werden können die auch semantisch gültig sind
Für die klassische Aussagenlogik bedeutet das einfacher Ein Kalkül ist genau dann korrekt wenn in ihm nur Tautologien bewiesen und nur gültige Argumente hergeleitet werden können
Ist es in einem aussagenlogischen Kalkül möglich mindestens ein ungültiges Argument herzuleiten oder mindestens eine Formel zu beweisen die keine Tautologie ist dann ist der Kalkül inkorrekt
Vollständigkeit
Vollständig semantisch vollständig heißt ein Kalkül genau dann wenn in ihm alle semantisch gültigen Formeln hergeleitet werden können für die klassische Aussagenlogik Wenn in ihm alle Tautologien hergeleitet werden können
Adäquatheit
Ein Kalkül heißt genau dann im Hinblick auf eine spezielle Semantik adäquat wenn er semantisch korrekt und semantisch vollständig ist
Ein metatheoretisches Resultat ist zum Beispiel die Feststellung dass alle korrekten Kalküle auch konsistent sind
Ein anderes metatheoretisches Resultat ist die Feststellung dass ein konsistenter Kalkül nicht automatisch korrekt sein muss Es ist ohne weiteres möglich einen Kalkül aufzustellen in dem zwar kein Widerspruch hergeleitet werden kann in dem aber z B
die nicht allgemeingültige Aussage der Form A
B hergeleitet werden kann
Ein solcher Kalkül wäre aus ersterem Grund konsistent aus letzterem Grund aber nicht korrekt
Ein weiteres sehr einfaches Resultat ist die Feststellung dass ein vollständiger Kalkül nicht automatisch auch korrekt oder nur konsistent sein muss
Das einfachste Beispiel wäre ein Kalkül in dem jede Formel der aussagenlogischen Sprache herleitbar ist
Da jede Formel herleitbar ist sind alle Tautologien herleitbar die ja Formeln sind Das macht den Kalkül vollständig
Da aber jede Formel herleitbar ist ist insbesondere auch die Formel P<num>
P<num> und die Formel A
B herleitbar Ersteres macht den Kalkül inkonsistent letzteres inkorrekt
Das Ideal das ein Kalkül erfüllen sollte ist Korrektheit und Vollständigkeit Wenn das der Fall ist dann ist er der ideale Kalkül für ein logisches System weil er alle semantisch gültigen Sätze und nur diese herleiten kann
So sind die beiden Fragen ob ein konkreter Kalkül korrekt undoder vollständig ist und ob es für ein bestimmtes logisches System überhaupt möglich ist einen korrekten und vollständigen Kalkül anzugeben zwei besonders wichtige metatheoretische Fragestellungen
Abgrenzung und Philosophie
Die klassische Aussagenlogik wie sie hier ausgeführt wurde ist ein formales logisches System
Als solches ist sie eines unter vielen die aus formaler Sicht gleichwertig nebeneinander stehen und die ganz bestimmte Eigenschaften haben Die meisten sind konsistent die meisten sind korrekt etliche sind vollständig und einige sind sogar entscheidbar
Aus formaler Sicht stehen die logischen Systeme in keinem Konkurrenzverhalten hinsichtlich Wahrheit oder Richtigkeit
Von formalen innerlogischen Fragen klar unterschieden sind außerlogische Fragen Solche nach der Nützlichkeit Anwendbarkeit einzelner Systeme für einen bestimmten Zweck und solche nach dem philosophischen speziell metaphysischen Status einzelner Systeme
Die Nützlichkeitserwägung ist die einfachere bezüglich deren Meinungsunterschiede weniger tiefgehend bzw weniger schwerwiegend sind
Klassische Aussagenlogik zum Beispiel bewährt sich in der Beschreibung elektronischer Schaltungen Schaltalgebra oder zur Formulierung und Vereinfachung logischer Ausdrücke in Programmiersprachen
Prädikatenlogik wird gerne angewandt wenn es darum geht Faktenwissen zu formalisieren und automatisiert Schlüsse daraus zu ziehen wie das unter anderem im Rahmen der Programmiersprache Prolog geschieht
Fuzzy-Logiken nonmonotone mehrwertige und auch parakonsistente Logiken sind hochwillkommen wenn es darum geht mit Wissensbeständen umzugehen in denen Aussagen mit unterschiedlich starkem Gewissheitsgrad oder gar einander widersprechende Aussagen abgelegt werden sollen und dennoch sinnvolle Schlüsse aus dem Gesamtbestand gezogen werden sollen
Auch wenn es je nach Anwendungsfall sehr große Meinungsunterschiede geben kann welches logisches System besser geeignet ist ist die Natur des Problems für alle Beteiligten unmittelbar und in gleicher Weise greifbar
Einzelwissenschaftliche Überlegungen und Fragestellungen spielen sich überwiegend in diesem Bereich ab
Noch kontroverser als solche pragmatischen Überlegungen sind Fragestellungen philosophischer und metaphysischer Natur
Geradezu paradigmatisch ist die Frage welches logische System richtig ist wobei richtig hier gemeint ist als Welches logische System nicht nur einen Teilaspekt der Wirklichkeit modellhaft vereinfacht sondern die Wirklichkeit das Sein als Ganzes adäquat beschreibt
Zu dieser Fragestellung gibt es viele unterschiedliche Meinungen einschließlich der vom philosophischen Positivismus eingeführten Meinung dass die Fragestellung als Ganzes sinnlos ist
In den Bereich metaphysischer Fragestellungen fällt auch die Frage ob es so etwas wie ein metaphysisches Prinzip der Zweiwertigkeit gebe ob also Aussagen über die Wirklichkeit durchgehend ins Schema wahrfalsch passen oder nicht
Diese Frage ist unabhängig von der Frage ob die Beschäftigung mit zwei- oder mehrwertigen Logiken praktisch sinnvoll ist Selbst wenn ein metaphysisches Prinzip der Zweiwertigkeit herrscht könnte man anwendungspraktisch mehrwertige Logiken nützen etwa dazu epistemische Sachverhalte zu fassen zum Beispiel aus Aussagen zu schließen die zwar metaphysisch wahr oder falsch sind von denen aber nicht oder noch nicht bekannt ist welches von beidem der Fall ist
Umgekehrt kann man auch dann wenn ein solches metaphysisches Prinzip nicht gilt zweiwertige Logik wegen ihrer Einfachheit für solche Anwendungen bevorzugen bei denen nur mit solchen Sätzen umgegangen werden muss die tatsächlich wahr oder falsch sind
Die Frage nach einem metaphysischen Prinzip der Zweiwertigkeit ist wie die meisten metaphysischen Fragen nicht endgültig zufriedenstellend beantwortet
Ein früher Einwand gegen ein solches Prinzip den Aristoteles zur Diskussion stellte war das Thema der Aussagen über zukünftige Sachverhalte Morgen wird es regnen Wenn Aussagen über Zukünftiges schon heute wahr oder falsch wären so wird argumentiert dann müsse die Zukunft bis ins letzte Detail vorbestimmt sein
Ein anderer Einwand der vorgebracht wird ist dass es Aussagen gibt deren Wahrheit praktisch oder theoretisch nicht festgestellt werden kann - zum Beispiel lässt sich die Wahrheit von Der Rasen vor dem Weißen Haus bestand am <num> Februar <num> aus genau <num><num> Grashalmen einfach nicht feststellen
Befürworter eines metaphysischen Zweiwertigkeitsprinzips berufen sich oft auf das Verhalten von Metatheoretikern also von Mathematikern oder Logikern die Aussagen über formale Systeme treffen Egal wie mehrwertig oder nichtklassisch das untersuchte System ist die dabei getroffenen Metavermutungen Metabehauptungen und Metafeststellungen sind immer zweiwertig Ein Kalkül auch ein parakonsistenter oder nonmonotoner wird immer als entweder konsistent oder inkonsistent betrachtet und ein logisches System ist immer entweder korrekt oder inkorrekt vollständig oder nicht vollständig entscheidbar oder unentscheidbar niemals ein bisschen von beidem
Befürworter deuten das als Hinweis darauf dass es in der Wirklichkeit tatsächlich eine strenge Unterscheidung nach wahr und falsch gebe oder dass es zumindest sinnvoll ist eine solche anzunehmen
Eine andere philosophische Fragestellung ist die nach dem metaphysischen Status des Untersuchungsgegenstands der Logik also danach was logische Systeme Kalküle Wahrheitswerte eigentlich sind
Der platonische Standpunkt besteht darin dass die in der Logik verwendeten Zeichen und Konstrukte eine außerlogische Bedeutung haben dass sie Namen für real existierende wenn auch natürlich nicht-physikalische Gegenstände sind
In diesem Sinn gäbe es so etwas wie das Wahre und das Falsche abstrakte Gegenstände die von den Zeichen wahr und falsch benannt werden
Der Gegenpol zum Platonismus wäre der Nominalismus der Existenz nur den Zeichen zuspricht die in der Logik manipuliert werden
Gegenstand der Logik sind Zeichen und die Tätigkeit der Logiker ist die Manipulation von Zeichen
Die Zeichen bezeichnen aber nichts so etwas wie das Wahre oder das Falsche gibt es also nicht
Im Grundlagenstreit der Mathematik entspräche der nominalistischen Position die formalistische Richtung
Eine Mittelstellung nähme der philosophische Konstruktivismus ein demzufolge die Zeichen zwar keine unabhängig existierenden Gegenstände bezeichnen durch den Umgang mit den Zeichen aber Gegenstände konstruiert werden
Literatur
Jon Barwise John Etchemendy The Language of First Order Logic
CSLI Lecture Notes Bd <num>
<num> Auflage revised and expanded
Center for the Study of Language and Information Stanford CA <num> ISBN <num>-<num>-<num>-<num>
Ansgar Beckermann Einführung in die Logik <num> neu bearbeitete und erweiterte Auflage
de Gruyter Berlin u a <num> ISBN <num>-<num>-<num>-<num>
Karel Berka Lothar Kreiser Logik-Texte
Kommentierte Auswahl zur Geschichte der modernen Logik
<num> gegenüber der <num> erweiterte durchgesehene Auflage
Akademie-Verlag Berlin <num>
Wolfgang Detel Grundkurs Philosophie Band <num> Logik
Universal-Bibliothek Nr <num>
Reclam Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Wilfrid Hodges Logic Penguin Books Harmondsworth <num> ISBN <num>-<num>-<num>-<num> <num> Auflage
ebenda <num> ISBN <num>-<num>-<num>-<num>
Rüdiger Inhetveen Logik
Eine dialog-orientierte Einführung
Eagle Bd <num>
Edition am Gutenbergplatz Leipzig <num> ISBN <num>-<num>-<num>-<num>
E J Lemmon Beginning Logic Nelson London <num> <num> Auflage
Chapman
Hall London <num> ISBN <num>-<num>-<num>-<num>
Wesley C Salmon Logik
Universal-Bibliothek Nr <num>
Reclam Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Weblinks
Vorlesungsmitschnitt Mathematik I Uni Tübingen
Die ersten zwei Stunden handeln ausführlich von Wahrheitstabellen
Christian Spannagel Aussagen- und Prädikatenlogik
Vorlesungsreihe <num>
Einzelnachweise
Karl Dürr Aussagenlogik im Mittelalter In Erkenntnis Bd <num> Nr <num> <num><num>
S <num>-<num> doi<num>BF<num> Achtung Verwechslungsgefahr Das ist kein Obermengenzeichen sondern das Kurven- Bogen- oder Hufeisenzeichen Peano-Russellsche Schreibweise - siehe Beitrag zur Implikation das Teilmengenzeichen welches gleich aussieht müsste sich auf die andere Seite öffnen Zur prädikatenlogischen Entsprechung siehe Prädikatenlogik erster Stufe SymboleE Grädel <num> S <num> f Zur prädikatenlogischen Entsprechung siehe Prädikatenlogik erster Stufe TermeVergleiche E Grädel <num> S <num> Bertrand Russell Mathematical logic as based on the theory of types In American Journal of Mathematics <num> <num> S <num> <num>-<num> PDF
<num> MB
Principia Mathematica
Band I S <num>f
Anthony Minghella CBE
<num> Januar <num> auf der Isle of Wight Großbritannien
<num> März <num> in London war ein britischer Filmregisseur Filmproduzent Drehbuchautor Dramatiker Hörspielautor Theater- und Opernregisseur
Leben
Minghella war der Sohn italienisch-schottischer Eltern die auf der Isle of Wight eine Fabrik für Eiscreme betrieben
Nach seinem Schulabschluss studierte er an der Universität Hull wo er eine Zeit lang als Dozent tätig war
<num> drehte er einen ersten Kurzfilm
Seit <num> war er als Autor und Story Editor tätig
Er wurde mit Theaterstücken Rundfunkhörspielen der Fernsehserie Inspector Morse und vielen Drehbüchern für Film und Fernsehen bekannt
Er entwickelte die Drehbücher für die <num> erfolgreich ausgestrahlte Fernsehserie The Storyteller von Muppets-Erfinder Jim Henson
Auch als Produzent war er erfolgreich darunter für die Filme
Der stille Amerikaner
Die Dolmetscherin
und
Der Vorleser
für den er <num> posthum für den Oscar Kategorie Bester Film nominiert wurde
Gemeinsam mit seinem Freund und Kollegen Sydney Pollack gründete er die Produktionsfirma Mirage Enterprises
Der Regisseur Minghella galt als ein guter Schauspielerführer Unter seiner Regie brachten es zahlreiche Darsteller zu Oscar-Nominierungen zwei Schauspielerinnen erhielten die Auszeichnung als Beste Nebendarstellerin Juliette Binoche Der englische Patient und Renée Zellweger Unterwegs nach Cold Mountain
Gegen Ende seines Lebens kehrte Minghella zu seinen Anfängen im Radio und auf der Bühne zurück <num> wurde sein Hörspiel Eyes Down Looking mit Jude Law zu Ehren von Samuel Beckett auf BBC Radio <num> ausgestrahlt ein Jahr zuvor hatte seine Inszenierung der Puccini-Oper Madame Butterfly in der English National Opera in London Premiere und wurde auch in der Nationaloper von Vilnius und in der Metropolitan Opera in New York gezeigt
Am Ende des Films
Abbitte
von Joe Wright <num> hat er einen Kurzauftritt als Talkshow-Moderator neben Vanessa Redgrave
Seine letzte Arbeit als Drehbuchautor war das Skript für den Musical-Film
Nine
gemeinsam mit Michael Tolkin
Zu seinen letzten Regiearbeiten zählt der Pilotfilm zur Krimiserie Eine Detektivin für Botswana
Originaltitel
den die BBC fünf Tage nach seinem Tod erstmals ausstrahlte
Minghella war mit der aus Hongkong stammenden Choreographin Produzentin und Schauspielerin Carolyn Choa
Wie verrückt und aus tiefstem Herzen
verheiratet
Der Ehe entstammen zwei Kinder die in der Filmbranche tätig sind Tochter Hannah Minghella in der Produktion und Sohn Max Minghella als Schauspieler
Agora - Die Säulen des Himmels
Die Tante Edana Minghella und der Onkel Dominic Minghella u a
für die deutsche Fernsehserie
Doktor Martin
sind Drehbuchautoren
Minghella starb im Alter von <num> Jahren in einem Londoner Krankenhaus an inneren Blutungen infolge der Operation eines Tonsillen karzinoms und eines Karzinoms im Nacken
Auszeichnungen
<num> erhielt Minghella den Londoner Kritikerpreis als meistversprechender junger Dramatiker <num> den Kritikerpreis für sein Stück Made in Bangkok als bestes Stück der Saison
<num> erhielt er für
Der englische Patient
den Oscar in der Rubrik
Beste Regie
<num> eine Oscar-Nominierung in der Kategorie Bestes adaptiertes Drehbuch für
Der talentierte Mr Ripley
bei dem er auch Regie führte
<num> wurde Minghella zum Commander of the British Empire CBE ernannt
Von <num> bis <num> war er Präsident des British Film Institute
Seit <num> trägt das Anthony Minghella Theatre auf der Isle of Wight seinen Namen
Filmografie als Regisseur Auswahl
<num> Wie verrückt und aus tiefstem Herzen Truly Madly Deeply
<num> Mr
Wonderful
<num> Der englische Patient The English Patient
<num> Der talentierte Mr Ripley The Talented Mr Ripley
<num> Unterwegs nach Cold Mountain Cold Mountain
<num> Breaking and Entering - Einbruch amp Diebstahl Breaking and Entering
<num> New York I Love You Szene
Weblinks
BBC <num> März <num> englisch
Image<num> degree rulesvgDiese Illustration zeigt die Achse zwischen den beiden Personen und den <num>-Bogen auf dem Kameras platziert werden können grün
enn zwischen dem grünen und dem roten Bogen geschnitten wird tauschen die Personen auf dem Bildschirm scheinbar Position und Blickrichtung
Ein Achsensprung ist ein Filmschnitt mit dem die Beziehungsachse der Figuren oder Gruppen übersprungen wird
Blickachsen oder Beziehungsachsen zwischen den Akteuren untereinander oder dem Point of Interest des Protagonisten bilden eine gedachte Linie
Auf die Leinwand projiziert stellt diese Linie eine links-rechts- und oben-unten-Beziehung zwischen den Akteuren dar
Mit Achsensprung bezeichnet man einen Schnitt bei dem sich dieses Verhältnis umkehrt
Es wird zwischen Seitenachsensprung und dem Höhenachsensprung unterschieden
Letzterer wird als weniger desorientierend vom Zuschauer empfunden da die Leinwand weniger hoch als breit ist
Ein Achsensprung kann beim Zuschauer Desorientierung verursachen da die Anordnung und Blickrichtung der Akteure im Frame sich relativ zum Zuschauer zu verändern scheint
Aktionsachse Handlungsachse ist die gedachte Linie in deren Richtung sich die Handlung oder das Inertialsystem der Filmwelt bewegt
Bei einer Autofahrt zum Beispiel ist die Aktionsachse so stark dass die Beziehungsachsen an Bedeutung verlieren
Die Orientierung bleibt trotz eventuellem Achsensprung bewahrt
Wenn man aus der Fahrerseite filmt bewegt sich die Landschaft scheinbar von rechts nach links filmt man aus der Beifahrerseite bewegt sie sich scheinbar von links nach rechts
Diese Änderung der Bewegungsrichtung ist aber nicht irritierend
Analog werden zwei Autos die bei einer Parallelmontage in die gleiche Richtung fahren oft von links nach rechts weil das unserer Leserichtung entspricht als einander verfolgend wahrgenommen wenn eines jedoch von links nach rechts und das andere von rechts nach links fährt erwartet der Zuschauer einen Zusammenstoß
Im Continuity Editing des klassischen Hollywoodkinos wird der Achsensprung als Fehler betrachtet und dementsprechend vermieden
Der Grundsatz Achsensprünge zu vermeiden wird <num>-Grad-Regel genannt
Bewusster Achsensprung
In manchen Fällen kann ein bewusster Achsensprung auch Stilmittel sein um beispielsweise Verwirrung oder einen Kippmoment zu symbolisieren Stanley Kubrick wird in diesem Zusammenhang häufig genannt
In Werbespots werden Achsensprünge oft verwendet um einen rasanten Effekt zu bewirken
Bekannt ist auch eine Szene aus
Herr der Ringe
in welcher Sméagol mit sich selbst spricht
Da er mit den Schnitten wechselnd von der einen zur anderen Seite spricht Achsensprung entsteht der Eindruck zweier gleich aussehender Personen womit der gespaltene Charakter der Figur unterstrichen wird
Achsenwechsel
Im Gegensatz zum Achsensprung handelt es sich hierbei um eine Bewegung der Kamera Steadicam oder einer Dollyfahrt über die Achse oder um eine Änderung der Bewegungsachse bzw der Blickrichtung der Figuren wodurch eine neue Achse definiert wird
Der Achsenwechsel wird vom Zuschauer nicht als störend wahrgenommen weil sich die Bewegung fließend vollzieht
Diese Bewegung wird mitunter auch als Crab bezeichnet
Außerdem kann ein Zwischenschnitt in eine Totale eine Achsenüberschreitung möglich machen da so die räumliche Anordnung der Akteure für den Zuschauer deutlich wird oder der Zwischenschnitt auf einen Closeup da sich der Betrachter danach wieder neu räumlich orientiert
Achsen im Film
Die Handlungsachse gibt die Hauptrichtung der Handlung an
Meist ist sie die Verbindung der Akteure bei einer Fußballübertragung die Verbindung der Tore
Die Blickachse gibt die Blickrichtung und den Blickwinkel Verhältnis zwischen der Höhen- und Seitenachse der Figuren an
Bei Gesprächen ist darauf zu achten dass sich die Figuren anschauen was bedeutet dass wenn eine Figur in einem Bild nach links oben schaut der Gesprächspartner im anderen Bild Gegenschuss nach rechts unten schaut
Diese Richtungen und die beiden Winkel sollten nicht verändert werden solange sich die reale Blickrichtung bzw der Standpunkt der Figuren nicht ändert
Die Kameraachse ist die Blickrichtung der Kamera
Bei einer subjektiven Perspektive Point of View ist sie mit der Blickachse identisch
Weblinks
Erklärvideo zu Achsensprung
DateiAlfred Hitchcock by Jack Mitchelljpg
Sir Alfred Joseph Hitchcock KBE
<num> August <num> in Leytonstone England
<num> April <num> in Los Angeles Kalifornien war ein britischer Filmregisseur Drehbuchautor Filmproduzent und Filmeditor
Er siedelte <num> in die USA über und nahm am <num> April <num> zusätzlich die amerikanische Staatsbürgerschaft an
Hitchcock gilt hinsichtlich seines Stils bis heute als einer der einflussreichsten Filmregisseure
Er etablierte die Begriffe Suspense und MacGuffin
Sein Genre war der Thriller charakteristisch seine Verbindung von Spannung mit Humor
Die wiederkehrenden Motive seiner Filme waren Angst Schuld und Identitätsverlust
Mehrfach variierte er das Thema des unschuldig Verfolgten
Hitchcock legte großen Wert auf die künstlerische Kontrolle über das Werk des Autors
Sein Gesamtwerk umfasst <num> Spielfilme und gehört - gemessen am Publikumserfolg sowie der Rezeption durch Kritik und Wissenschaft - zu den bedeutendsten der Filmgeschichte
Auch dank seiner bewussten Selbstvermarktung zählt Hitchcock heute zu den bekanntesten zeitgeschichtlichen Persönlichkeiten
Er ist dem Autorenfilm zuzurechnen
Am <num> Januar <num> wurde er von Königin Elisabeth II zum Knight Commander des Order of the British Empire ernannt
Leben und Werk
Kindheit Jugend und Ausbildung
Alfred Hitchcock war der jüngste Sohn des Gemüsehändlers William Hitchcock <num>-<num> und dessen Ehefrau Emma Jane Whelan <num>-<num> Durch den Altersunterschied von sieben beziehungsweise neun Jahren zu seinen Geschwistern durch seine römisch-katholische Erziehung in einem von der anglikanischen Kirche geprägten Land und nicht zuletzt durch sein Äußeres - er war klein und schon als Kind korpulent - hatte er eine einsame Kindheit
Zwischen <num> und <num> war er Schüler des St-Ignatius-College einer Londoner Jesuiten-Schule Er verließ das College mit knapp <num> Jahren und besuchte stattdessen Abendkurse auf der Londoner Universität diverse Handwerkskurse und später wenige Monate lang die School of Engineering and Navigation
Zudem belegte er Kurse in technischem Zeichnen sowie in Kunstgeschichte
an der Londoner Kunstakademie
Seine Freizeit verbrachte er großteils mit dem Lesen von Fahrplänen und dem Studium von Stadtplänen und Landkarten
Mit fortschreitendem Alter flüchtete er sich in Romane besuchte Theatervorstellungen und ging oft ins Kino
Außerdem verfolgte er Mordprozesse im Gerichtshof Old Bailey und besuchte gerne das Black Museum von Scotland Yard
Der Tod des Vaters Ende <num> zu dem er kein enges Verhältnis hatte band Hitchcock noch enger an seine Mutter
<num> nahm er eine Stelle als technischer Angestellter bei der WT
Henley Telegraph Company
an die elektrische Leitungen herstellte
Wegen seines zeichnerischen Talents wurde er bald in die Werbeabteilung versetzt
Unter seinem bis zuletzt gebrauchten Spitznamen Hitch veröffentlichte er in der Betriebszeitschrift seine ersten gruseligen Kurzgeschichten
Anstellung beim Film
Im Frühjahr <num> hörte Hitchcock von der Neugründung eines Studios der amerikanischen Produktionsgesellschaft Paramount Famous Players-Lasky im Londoner Stadtbezirk Islington
Er bewarb sich mit einer Mappe mit Illustrationen und wurde als Zeichner von Zwischentiteln angestellt
In den Jahren <num> und <num> zeichnete er die Titel für mindestens zwölf Filme
Nebenbei entwarf er Kostüme Dekorationen und Szenenbilder
Auch durch Überarbeitungen von Drehbüchern machte er auf sich aufmerksam
Bei zwei Filmen arbeitete er mit George Fitzmaurice zusammen dessen genaue Produktionsplanung ihn sehr beeinflusste
<num> bekam Hitchcock Gelegenheit sich als Regisseur zu versuchen
Mit dem Autor Seymour Hicks stellte er die letzten Filmszenen von Always Tell Your Wife fertig nachdem der ursprüngliche Regisseur gefeuert worden war
Bald darauf konnte er einen eigenen Film drehen Number <num> in einigen Quellen Mrs
Peabody
der jedoch unvollendet blieb da Famous Players-Lasky im Laufe der Dreharbeiten das Studio wegen finanzieller Schwierigkeiten schließen musste
Das leerstehende Gelände wurde an unabhängige Produzenten vermietet darunter auch an Michael Balcon der das Studio <num> schließlich erwarb
Er stellte Hitchcock als Regieassistent ein sowie auf dessen Empfehlung die Filmeditorin Alma Reville
Die beiden kannten sich seit <num> seitdem sie gelegentlich an denselben Filmen gearbeitet hatten
Bis <num> entstanden fünf Filme bei denen Hitchcock dem Regisseur Graham Cutts assistierte und zu Cutts wachsendem Unmut mehr und mehr künstlerischen Einfluss gewann
Neben dem Drehbuch kümmerte er sich auch um die Bauten das Szenenbild die Besetzung die Kostüme sowie die Ausstattung und nahm so mit der Zeit die Aufgaben eines Produktionsleiters wahr
Hitchcocks letzte Zusammenarbeit mit Graham Cutts führte ihn <num><num> nach Deutschland
Der unter der Beteiligung der deutschen UFA produzierte Film
Die Prinzessin und der Geiger
entstand in den Babelsberger Filmstudios - damals den modernsten der Welt
Dabei hatte Hitchcock die Möglichkeit Friedrich Wilhelm Murnau bei den Arbeiten an
Der letzte Mann
zu beobachten von diesem beeindruckt übernahm er einige Techniken Murnaus für die Szenenbilder seiner aktuellen Produktion Durch diesen und weitere Besuche konnte Hitchcock fließend Deutsch sprechen später sprach er zum Beispiel einige Trailer seiner Filme selbst
Zurück in England übertrug ihm Michael Balcon <num> die Regie für einen eigenen Film
Das Projekt führte den jungen Hitchcock wieder nach Deutschland
Nur die Münchner Lichtspielkunst Emelka fand sich bereit den Film des unbekannten Regie-Debütanten mitzuproduzieren
Für das Melodram
Irrgarten der Leidenschaft
<num> verpflichtete Balcon kostspielige Stars aus Hollywood
Alma Reville mittlerweile Hitchcocks Verlobte war als Regieassistentin und Editorin Mitglied des sehr kleinen Filmteams
Balcon war mit Hitchcocks ambitionierter Arbeit zufrieden und vertraute ihm eine weitere deutsch-englische Koproduktion an
Der Bergadler
wurde noch im selben Jahr diesmal in Tirol gedreht
Doch beide Filme die <num> beziehungsweise <num> in Deutschland in den Kinos anliefen wurden in England zunächst nicht veröffentlicht
Der englische Verleiher und Geldgeber C M
Woolf war im Gegensatz zu Balcon nicht von Hitchcocks betont expressionistischem Stil überzeugt
Der Bergadler ist der einzige von Hitchcocks Filmen der nicht mehr erhalten ist
Karriere in England
Leben und Arbeit in England
Mit dem <num> gedrehten Film
Der Mieter
um einen einzelgängerischen Pensionsgast der verdächtigt wird ein Serienmörder zu sein hatte Hitchcock sein Thema gefunden Doch nicht zuletzt wegen dessen expressionistischer Bildgestaltung lehnte es Woolf abermals ab den Film zu veröffentlichen
Balcon zog daraufhin den jungen Ivor Montagu hinzu der Erfahrung mit Filmüberarbeitungen hatte mit Hitchcock zusammen wurden einige Änderungen vorgenommen
Der überragende Erfolg bei einer Pressevorführung ebnete dann den Weg zur Veröffentlichung seiner ersten beiden Filme Der Mieter kam <num> in kurzer Abfolge mit Irrgarten der Leidenschaft und Der Bergadler in die Kinos und bedeutete für Hitchcock den Durchbruch als Regisseur
Für Balcons Gainsborough Pictures drehte Hitchcock <num> noch die zwei Melodramen
Abwärts
und
Easy Virtue
Beiden Filmen war kein Erfolg beschieden
Bereits zuvor hatte er beschlossen bei deutlich höherem Gehalt zu der neu gegründeten Firma British International Pictures BIP des Produzenten John Maxwell zu wechseln
Dort entstand mit dem Boxerdrama
Der Weltmeister
sein erster Film nach einem Originaldrehbuch
Die Presse reagierte äußerst positiv
Obwohl die drei folgenden Stummfilme
The Farmers Wife Champagne
und
Der Mann von der Insel Man
abgesehen von einzelnen Szenen als Fingerübungen gelten hatte sich Hitchcock in Großbritannien innerhalb kurzer Zeit einen Namen gemacht Die junge britische Filmindustrie sehr darauf bedacht sich von der amerikanischen abzuheben war nur allzu gerne bereit ihn als kommenden Regiestar zu feiern
Im Dezember <num> heirateten Alfred Hitchcock und Alma Reville die für die Hochzeit zum katholischen Glauben konvertierte
<num> wurde ihre gemeinsame Tochter Patricia geboren
Beruflich blieb Alma bis zum Schluss seine engste Mitarbeiterin und Beraterin
Das Aufkommen des Tonfilms hielten viele Regisseure für das Ende ihrer Kunstform
Hitchcock hingegen nutzte das Potential der neuen Technik
Erpressung
<num> wurde ursprünglich als Stummfilm produziert
Die Produzenten erlaubten Hitchcock jedoch eine Filmrolle mit Tonmaterial nachzudrehen
Er versah daraufhin einzelne Schlüsselszenen mit wirkungsvollen Toneffekten und gesprochenem Dialog wobei die tschechische Schauspielerin Anny Ondra die ihre Rolle stumm spielen musste von der englischen Schauspielerin Joan Barry simultan synchronisiert wurde
Erpressung war der erste britische Tonfilm und wurde ein großer Erfolg
Hitchcock nutzte seine gewonnene Popularität und gründete mit der Hitchcock Baker Productions Ltd eine Gesellschaft zur Vermarktung seiner Person
Auf Geheiß seines Studios drehte er
Juno and the Paycock
<num> sowie einige Szenen für die Musikrevue
Elstree Calling
Mit
Mord - Sir John greift ein
fand er wieder zu seinem Thema und auch nach Deutschland zurück In Berlin stellte er die deutsche Sprachversion des Films unter dem Titel
Mary
her Es folgten drei Filme von denen Hitchcock nur die Komödie
Endlich sind wir reich
wirklich interessierte In dem zusammen mit seiner Frau und Val Valentine verfassten Drehbuch verarbeitete er unter anderem die Erfahrungen seiner noch jungen Ehe
Den ihm aufgezwungenen Thriller
Nummer siebzehn
beschloss Hitchcock aus Protest zu sabotieren und zu einer wirren albernen Parodie zu machen
Die turbulente Verbindung zwischen Humor und Spannung lässt Nummer siebzehn aus heutiger Sicht als einen Vorläufer späterer Klassiker des Genres erscheinen
Hitchcocks Vertrag mit der British International Pictures endete nach sechs Jahren mit einem Einsatz als Produzent Lord Cambers Ladies
Die Zusammenarbeit hatte zunehmend unter dem Konflikt zwischen Hitchcocks Streben nach künstlerischer Kontrolle und den Vorschriften des Studios gelitten
Doch auch den folgenden Film
Waltzes from Vienna
ein Musical ohne Musik Hitchcock für den unabhängigen Produzenten Tom Arnold drehte er betont lustlos Ich hasse dieses Zeug
Melodrama ist das einzige was ich wirklich kann
Englische Meisterwerke
Unmittelbar nach Waltzes from Vienna nahm er die fruchtbare Zusammenarbeit mit dem Produzenten Michael Balcon wieder auf
Als erster Film für die Gaumont British entstand der Thriller
Der Mann der zuviel wußte
<num>
Das Drehbuch erarbeitete Hitchcock im Wesentlichen mit seiner Frau Alma und dem Drehbuchautor Charles Bennett
Der Film wurde sowohl von der Kritik als auch vom Publikum enthusiastisch aufgenommen
Der humorvolle Spionagethriller
Die <num> Stufen
<num> Drehbuch Charles Bennett gilt als Blaupause späterer Verfolgungsthriller
Eine turbulente Szene folgt auf die nächste es gibt keine Übergänge und kaum Zeit für den Zuschauer über die manches Mal fehlende Logik nachzudenken
Hitchcock ordnete nach eigenem Bekunden alles dem Tempo unter
Der überragende Erfolg des Films sollte ihm recht geben
Es folgten
Geheimagent
<num> und
Sabotage
<num> die insbesondere in Hitchcocks eigener späterer Bewertung gegenüber den beiden Vorgängerfilmen abfielen
Doch die psychologisch vielschichtige Behandlung des Themas Schuld weist bereits auf spätere Werke hin
Nach Sabotage endete abrupt die zweite erfolgreiche Phase der Zusammenarbeit mit Michael Balcon als die Produktionsfirma Gaumont British von deren Besitzern geschlossen und Balcon entlassen wurde
Die beiden folgenden Filme drehte Hitchcock daher wieder für die Gainsborough Pictures - diesmal allerdings ohne seinen ehemaligen Förderer
Jung und unschuldig
<num> war eine weitere unbeschwerte Variation der Geschichte vom unschuldig Verfolgten
Der gefeierte Thriller
Eine Dame verschwindet
<num> spielt überwiegend in einem fahrenden Zug
Die Dreharbeiten fanden jedoch ausschließlich in einem kleinen Londoner Studio statt was dank technisch anspruchsvoller Rückprojektionen möglich wurde
Hitchcock festigte mit diesen sechs Filmen seine Ausnahmestellung innerhalb des britischen Kinos
Ende der <num>er Jahre beauftragte er die Selznick-Joyce-Agentur deren Mitinhaber Myron Selznick der ältere Bruder des Hollywood-Moguls David O Selznick war seine Interessen wahrzunehmen Hitchcock dessen Ruf mittlerweile bis nach Hollywood gelangt war unterzeichnete schließlich <num> einen Vertrag für die Produktionsgesellschaft von David O Selznick der damals gerade mit der Vorproduktion zu
Vom Winde verweht
beschäftigt war
In Gedanken bereits in Hollywood drehte Hitchcock in England noch einen letzten Film für die Produktionsfirma des nach England emigrierten deutschen Produzenten Erich Pommer
Doch der Kostümfilm Riff-Piraten
wurde von der Presse durchweg verrissen
Hollywood und der Zweite Weltkrieg
In seinen ersten Jahren in Hollywood stieß Hitchcock auf unerwartete Schwierigkeiten
David O Selznick übte starke Kontrolle über die Filme seines Studios aus und achtete darauf dass sich der freiheitsliebende Hitchcock möglichst eng an die literarische Vorlage seines ersten Hollywoodfilmes hielt
Trotz dieser Spannungen wurde
Rebecca
für den britischen Regisseur ein erfolgreicher Einstand in Hollywood Das psychologisch dichte und düster-romantische Melodram war <num> elfmal für den Oscar nominiert und gewann schließlich zwei der Trophäen Kamera und Produktion
In den nächsten Jahren machte Selznick sein Geld mit Hitchcock indem er ihn für beträchtliche Summen an andere Studios auslieh
Der Krieg in Europa weitete sich aus als der unabhängige Produzent Walter Wanger Hitchcock für ein aktuelles Kriegsdrama engagierte
Der Auslandskorrespondent
blieb Hitchcocks Naturell entsprechend jedoch ein weitgehend unpolitischer Spionagethriller
Nur der nachgedrehte Schlussmonolog gerichtet an die noch neutralen USA wirkte aufrüttelnd
Kurz nach Fertigstellung des Films wurde England von Deutschland bombardiert
Der rechtzeitig ausgewanderte Hitchcock musste sich daraufhin scharfe Kritik von ehemaligen britischen Kollegen allen voran Michael Balcon gefallen lassen
Mit
Verdacht
<num> RKO der ersten Zusammenarbeit mit Cary Grant und
Saboteure
<num> Universal blieb Hitchcock bei seinen klassischen Themen
Zwischen diesen Produktionen drehte er für ihn und andere ungewohnt seine einzige Screwball-Komödie
Obwohl damals durchaus positiv aufgenommen zeigte er sich mit
Mr
und Mrs Smith
<num> RKO nicht zufrieden
Weit mehr am Herzen lag ihm die Arbeit an dem Drama
Im Schatten des Zweifels
<num> Universal
Hitchcocks Filme gelten allgemein als stark von seinem Charakter geprägt
Dieses Familienmelodram wird als einer seiner persönlichsten Filme bezeichnet In allen Hauptfiguren spiegeln sich demnach Eigenschaften und Ängste Hitchcocks
Als während der Dreharbeiten Hitchcocks Mutter in London starb verstärkte dies die autobiografischen Tendenzen
Wie viele britische Regisseure leistete Hitchcock seine Beiträge für die Kriegspropaganda und drehte unter anderem Kurzfilme zur Unterstützung der französischen Résistance
Auch in seine nächste Hollywood-Produktion arbeitete er stark propagandistische Töne ein doch sein stets bewusst irritierender Umgang mit Klischees sorgte diesmal für Kontroversen In einem kleinen Rettungsboot sehen sich englische und amerikanische Schiffbrüchige einem intellektuell überlegenen Nazi gegenüber
Dennoch wurde der formalistisch strenge Psychothriller
Das Rettungsboot
<num> <num>th Century Fox dreimal für den Oscar nominiert Drehbuch Kamera und Regie
Psychologie wichtige Komponente seines Werks stand im Mittelpunkt von
Ich kämpfe um dich
<num> der nach langer Zeit wieder für Selznick entstand
Dieser war vom Thema Psychoanalyse schnell begeistert und ließ Hitchcock ungewohnt viel freie Hand doch kürzte er den Film nach der ersten Probevorführung um rund zwanzig Minuten
Die erfolgreiche Zusammenarbeit mit Ingrid Bergman in der Hauptrolle wurde in der folgenden Produktion
Berüchtigt
<num> fortgesetzt die Selznick allerdings wieder an RKO verkaufte
Die Geschichte um eine Spionin Bergman die aus Pflichtgefühl von ihrem Liebhaber Cary Grant gedrängt wird mit dem Feind zu schlafen bot für Hitchcocks Obsessionen eine breite Projektionsfläche
Mit dem Gerichtsdrama
Der Fall Paradin
<num> lief der Vertrag Hitchcocks mit Selznick aus
Selznick behielt bei der Stoffauswahl angefangen bei dieser relativ chaotisch verlaufenden Produktion die Oberhand
Dass Hitchcock währenddessen Vorbereitungen für seine eigene Produktionsfirma traf verstärkte die Spannungen zwischen den machtbewussten Männern
Dennoch bot Selznick Hitchcock - erfolglos - eine Vertragsverlängerung an
Unabhängigkeit
DateiAlfred Hitchcock NYWTSjpg Bereits im April <num> rund zwei Jahre bevor der Vertrag mit Selznick auslaufen sollte gründete Hitchcock mit dem befreundeten Kinokettenbesitzer Sidney Bernstein die Produktionsfirma Transatlantic Pictures für die er seinen ersten Farbfilm inszenierte
Cocktail für eine Leiche
<num> mit James Stewart in einer der Hauptrollen
Der Film blieb jedoch vor allem wegen eines anderen Hitchcock-Experiments in Erinnerung jede Einstellung des kammerspielartigen Films dauert so lange wie es das Filmmaterial in der Kamera erlaubte also rund zehn Minuten
Durch geschickte Übergänge sollte so der Eindruck entstehen dass sich die Geschichte in Echtzeit und von nur einer Kamera gefilmt ereignete
Sklavin des Herzens
<num> ein für Hitchcock untypischer melodramatischer Kostümfilm war vor allem ein Vehikel für Ingrid Bergman
Trotz der Starbesetzung und der technischen Raffinessen wurde er kommerziell ein ähnlicher Misserfolg wie Cocktail für eine Leiche - Transatlantic ging daraufhin in Konkurs
Nachdem sein Berater und Agent Myron Selznick <num> gestorben war wurden Hitchcocks Interessen von mehreren anderen Personen wahrgenommen bevor er <num> mit Lew Wasserman zusammentraf
Wasserman war seit <num> Präsident der weltgrößten Künstleragentur Music Corporation of America MCA der sich Hitchcock <num> anschloss
Es begann eine enge wie äußerst lohnende Zusammenarbeit
Warner Brothers
Hitchcock schloss mit Warner Bros einen lukrativen Vertrag über vier Filme ab bei denen er als Regisseur und Produzent angefangen bei der Stoffauswahl völlig freie Hand hatte Der erste dieser Filme war der Thriller
Die rote Lola
<num> mit Marlene Dietrich der im Londoner Theatermilieu spielte
Eines seiner Lieblingsmotive stellte er auf den Kopf am Ende entpuppt sich der unschuldig Verfolgte als der wahre Mörder
Hitchcock drehte in seiner Heimat spürte allerdings wieder die alten Ressentiments die nach seiner Auswanderung entstanden waren
Der Film selbst war nicht sonderlich erfolgreich
Im April <num> begann Hitchcock regelmäßige Kolloquien an den Universitäten von Kalifornien und Südkalifornien abzuhalten in denen unter anderem Previews seiner aktuellen Filme gezeigt wurden
Diese Tradition sollte er die kommenden <num> Jahre beibehalten
Der Fremde im Zug
<num> nach einem Roman von Patricia Highsmith brachte schließlich nach fünf Jahren Flaute wieder einen überragenden Erfolg
Mit diesem Film begann die dreizehnjährige Zusammenarbeit mit dem Kameramann Robert Burks
Wie schon in Die rote Lola spielte Hitchcocks Tochter Patricia eine Nebenrolle
<num> folgte mit
Ich beichte
der eindeutigste filmische Bezug auf Hitchcocks starke katholische Prägung
Obwohl von der Kritik geschätzt floppte der Film an den Kinokassen was Hitchcock vor allem der Humorlosigkeit des Publikums anlastete
Als Anfang der <num>er Jahre das Fernsehen Einzug in die Wohnzimmer hielt versuchte die Kinoindustrie mit neuen technischen Verfahren wie dem Breitbildformat Cinemascope oder dem <num>D-Verfahren den Zuschauerschwund aufzuhalten
So drängte Warner Bros
Hitchcock seinen nächsten Film in <num>D zu drehen
Über diese Entscheidung die zur Einschränkung der Bewegungsfreiheit der Kamera führte war Hitchcock nicht glücklich er setzte auch nur wenige explizite <num>-D-Effekte ein
Bei Anruf Mord
<num> ist die Verfilmung eines damals sehr populären Theaterstücks von Frederick Knott der auch das Drehbuch schrieb
Mit Hauptdarstellerin Grace Kelly drehte Hitchcock im Anschluss noch zwei weitere Filme ehe sie sich aus dem Filmgeschäft zurückzog
Paramount
Die Erfahrung mit dem aufgezwungenen <num>D-Verfahren zeigte Hitchcock die Grenzen bei Warner Brothers
Er schloss daher <num> einen Vertrag mit Paramount ab der ihm völlige künstlerische Freiheit garantierte
<num> begann die für Hitchcock erfolgreichste Zeit mit
Das Fenster zum Hof
Neben Grace Kelly ist ein weiteres Mal James Stewart zu sehen
Die Hauptfigur sitzt während des gesamten Films im Rollstuhl und beobachtet durch ein Teleobjektiv das Geschehen in den gegenüberliegenden Wohnungen - sozusagen stellvertretend für den Zuschauer aber auch stellvertretend für Hitchcock selbst der in diesem Film den voyeuristischen Aspekt des Filmemachens aufzeigt
Über den Dächern von Nizza
<num> ist ein leichter romantischer Thriller in dem neben Grace Kelly - nach zwei Jahren Filmpause - wieder Cary Grant spielte
Wohl um dem Glamour dieses an der Côte dAzur angesiedelten Films etwas entgegenzusetzen drehte Hitchcock noch im selben Jahr die kostengünstig produzierte schwarze Komödie
Immer Ärger mit Harry in der Shirley MacLaine neben John Forsythe ihren ersten Filmauftritt hatte
Edmund Gwenn der bereits in früheren Hitchcock-Filmen mitgewirkt hatte spielte fast achtzigjährig eine seiner wenigen Hauptrollen
Obwohl Hitchcock in vielen seiner Filme schwarzen Humor untergebracht hat ist es eine der wenigen echten Komödien von ihm
<num> nahm Hitchcock - rund fünf Jahre nach seiner Frau - die amerikanische Staatsbürgerschaft an
Im selben Jahr begann er mit Doris Day und James Stewart die Dreharbeiten zu
Der Mann der zuviel wußte
<num> dem einzigen Remake eines seiner Filme in seiner Karriere
Ebenfalls <num> startete die wöchentliche Fernsehserie
Alfred Hitchcock Presents
ab <num> The Alfred Hitchcock Hour
Hitchcock war Produzent trat in vielen Folgen als Moderator auf und inszenierte insgesamt <num> Folgen
Auch für die Fernsehserien
Suspicion
und
Startime
nahm er für je eine Folge im Regiestuhl Platz
Nach zehn Jahren beendete er seine Fernseharbeit an der er zunehmend das Interesse verloren hatte
Hinzu kam dass die Produktion den Auftraggebern zu teuer wurde und die Zeit von Serien mit jeweils abgeschlossenen Folgen sogenannten Anthologies zu Ende ging
Mit
Der falsche Mann
wurde er <num> einem seiner Grundprinzipien der strikten Trennung von Leben und Fiktion untreu
In dem Schwarzweißfilm mit Henry Fonda und Vera Miles wird an authentischen Schauplätzen die auf Tatsachen beruhende Geschichte eines zu unrecht Verurteilten erzählt
Der Film entstand noch einmal für Warner Bros da Hitchcock dem Studio bei seinem Ausscheiden noch einen Film ohne Regiegage zugesagt hatte
Allerdings war Der falsche Mann der viele Stilelemente des Film noir und ein trostloses Ende aufweist kommerziell ein Flop
Höhepunkt und Wende
<num> drehte Hitchcock seinen letzten Film für Paramount
Vertigo - Aus dem Reich der Toten
<num> veröffentlicht
Das Drehbuch entstand in gemeinsamer intensiver Arbeit von Hitchcock und Samuel A Taylor
In wenige seiner Filmfiguren projizierte Hitchcock wohl so viel von seiner eigenen Persönlichkeit wie in den von James Stewart verkörperten Scottie Ferguson der versucht eine Frau nach seinen Vorstellungen umzuformen
Zu seiner Entstehungszeit nicht besonders erfolgreich zählt der Film inzwischen - ähnlich wie der folgende
Der unsichtbare Dritte
- zu den bedeutendsten Werken Hitchcocks Hitchcock und sein Drehbuchautor Ernest Lehman konzipierten Der unsichtbare Dritte <num> MGM als eine Abfolge von Abenteuern in denen ein Unschuldiger Cary Grant in seinem letzten Hitchcock-Film um seine Reputation und sein Leben kämpft
Die elegante Leichtigkeit der Erzählung beeinflusste viele nachfolgende Abenteuer- und Agentenfilme was sich u a in den James-Bond-Filmen der darauf folgenden Jahre zeigt
Für Hitchcock selbst blieb es für lange Zeit der letzte vorwiegend heitere Film
Das im Anschluss vorbereitete Projekt mit Audrey Hepburn in der Hauptrolle wurde durch Hitchcock gestoppt als Hepburn wegen einer geplanten Vergewaltigungsszene absagte Mit seiner bewusst kostengünstigen Produktion
Psycho
<num> folgte Hitchcocks wohl bekanntester Film Die in einer Woche Dreharbeit entstandene Duschszene zählt heute zu seinen meistanalysierten Filmszenen
Ungewöhnlich war auch der Tod einer Hauptfigur nach nur einem Drittel des Films
Die zeitgenössischen Kritiken fielen unerwartet barsch aus doch das Publikum machte Psycho zu Hitchcocks größtem kommerziellen Erfolg
Nachdem zwei angedachte Projekte scheiterten - unter anderem weil Walt Disney dem Psycho-Regisseur die Dreherlaubnis in Disneyland verweigerte - nahm Hitchcock seinen nächsten Film erst Mitte <num> in Angriff
Die Vögel
<num> ein weiterer Horrorfilm der nicht zuletzt durch seine Dramaturgie und die eingesetzte Tricktechnik - etwa den Sodium Vapor Process - stilbildend wirkte
Der deutsche Komponist Oskar Sala setzte statt Filmmusik elektronisch erzeugte Geräusche ein
Seine Hauptdarstellerin Tippi Hedren hatte Hitchcock im Werbefernsehen entdeckt
Obwohl sie keine Filmerfahrung besaß nahm er sie für die nächsten sieben Jahre unter Vertrag
Die Vögel entstand für Universal die kurz zuvor teilweise von MCA übernommen worden waren und für die Hitchcock von nun an alle seine Filme drehen sollte
Lew Wasserman bis zu diesem Zeitpunkt Agent Hitchcocks wurde Präsident von Universal und gab seine Agententätigkeit auf
Hitchcock selbst trat seine Rechte an Psycho und seiner Fernsehserie ab und wurde im Gegenzug der drittgrößte Aktionär von MCA
Nach Die Vögel gibt es in Hitchcocks Werk einen Bruch
Die folgenden drei Filme der <num>er Jahre blieben künstlerisch und kommerziell hinter den vorangegangenen Erfolgen zurück
Konflikte mit seiner Hauptdarstellerin Tippi Hedren prägten die Dreharbeiten so weit dass er das Gelingen seines nächsten Films
Marnie
<num> bewusst zu sabotieren schien Das Psychogramm einer verstörten traumatisierten Frau bedient sich psychologischer Erklärungsmodelle die überholt und undifferenziert wirken und enthält für Hitchcock untypisch viele handwerkliche Fehler
Dieser erste künstlerische und kommerzielle Misserfolg seit rund fünfzehn Jahren war in mehrfacher Hinsicht ein Wendepunkt in Hitchcocks Karriere
Tippi Hedren war die letzte typische Hitchcock-Blondine Marnie der letzte Film den Hitchcocks langjähriger Kameramann Robert Burks drehte Kurz nach Abschluss der Dreharbeiten verstarb zudem Hitchcocks Filmeditor George Tomasini mit dem er zehn Jahre lang zusammengearbeitet hatte
Das Spätwerk
Erfolge und eine Rückkehr in die Heimat
Filmproduktionen wurden immer aufwendiger der Erfolg an der Kinokasse immer wichtiger
Diverse Projekte die Hitchcock reizten und die er mehr oder weniger intensiv plante kamen so aus Angst der Produzenten nicht zustande - etwa Mary Rose die geplante Verfilmung eines skurrilen Theaterstücks Mit RRRR einem Drehbuch mit zahlreichen Verwicklungen über eine italienische Ganoven-Familie in New York wollte er Jahre nach Der unsichtbare Dritte wieder einen komischen Thriller drehen und damit alle Nachahmer Charade
Topkapi
und andere übertreffen
Das weit fortgeschrittene Projekt scheiterte schließlich an unüberbrückbaren sprachlichen und kulturellen Problemen mit den italienischen Mitarbeitern
Am <num> März <num> erhielt Hitchcock für seinen historischen Beitrag zum amerikanischen Kino den Milestone Award der Producers Guild Of America - die erste von vielen Ehrungen für sein Lebenswerk
Mit
Der zerrissene Vorhang
<num> kehrte Hitchcock schließlich zum Genre des Spionagefilms zurück in dem er bereits in den <num>er Jahren in England große Erfolge gefeiert hatte
Die Premiere dieses <num> Hitchcock-Filmes sollte von einer groß angelegten Marketingkampagne begleitet werden
Nicht nur aus diesem Grund setzte Universal die aktuellen Stars Paul Newman und Julie Andrews gegen Hitchcocks Widerstand als Hauptdarsteller durch
Überdies kam es zum Bruch mit dem Komponisten Bernard Herrmann als dieser nicht die von Universal gewünschte auch für den Schallplattenverkauf geeignete Unterhaltungsmusik vorlegte
Auch an anderen wichtigen Positionen seines Stabes musste Hitchcock auf vertraute Mitarbeiter verzichten
Der zerrissene Vorhang fällt handwerklich und dramaturgisch gegenüber Hitchcocks letzten Filmen einschließlich Marnie deutlich ab und wurde von der Kritik durchweg verrissen
Universal forderte von ihm zeitgemäßere Themen ein
Als das von ihm und Howard Fast detailliert ausgearbeitete Drehbuch über einen homosexuellen Frauenmörder abgelehnt wurde zog er sich für ein Jahr ins Privatleben zurück Anfang <num> entschloss er sich unter dem Druck der langen Pause seit dem letzten Film und der noch längeren Zeitspanne seit dem letzten Erfolg den Spionageroman
Topas
von Leon Uris zu verfilmen dessen Rechte Universal kurz zuvor erworben hatte
Topas wurde dann fast ausschließlich mit europäischen Schauspielern besetzt und völlig ohne Hollywood-Stars
In Europa waren die Französinnen Dany Robin und Claude Jade wie ihre Landsmänner Michel Piccoli und Philippe Noiret und die deutsche Aktrice Karin Dor Stars die für amerikanische Zuschauer bekanntesten Gesichter waren der Fernsehschauspieler John Forsythe und der aus Kanada stammende John Vernon
Das endgültige Drehbuch wurde erst während der laufenden Dreharbeiten geschrieben der Schluss nach einer katastrophalen Preview improvisiert
Publikum und Kritik reagierten mit Ablehnung auf Hitchcocks bis dahin teuersten Film doch er zeigte sich zuversichtlich Ich habe meinen letzten Film noch nicht gedreht
Topas
ist mein <num> Film aber wann ich meinen letzten Film drehen werde ist von mir meinen Finanziers und Gott noch nicht entschieden worden
Im Spätsommer <num> nahm Hitchcock sein nächstes Projekt in Angriff und reiste dafür wieder in seine Heimat wo er diesmal begeistert empfangen wurde
Frenzy
<num> spielt in London dem Hitchcock eine liebevolle Hommage erweist und ist in seinen Worten die Geschichte eines Mannes der impotent ist und sich deshalb durch Mord ausdrückt Zunächst verliefen die Drehbucharbeit und auch die Dreharbeiten die Hitchcock so ernst nahm wie lange nicht mehr weitgehend reibungsfrei
Doch als seine Frau Alma einen Herzinfarkt erlitten hatte wurde Hitchcock müde und untätig die Crew war ähnlich wie bei den drei vorangegangenen Filmen wieder weitgehend auf sich alleine gestellt Dennoch wurde Frenzy ein brutaler zum Teil bitterer von tiefschwarzem britischen Humor durchzogener Film und ein großer Erfolg
Nur in England war man enttäuscht und bemängelte vor allem die anachronistisch wirkende Darstellung von London und des britischen Lebens
Der letzte Film
Im Frühjahr <num> entschloss sich Hitchcock den Roman The Rainbird Pattern von Victor Canning zu verfilmen
Doch die Arbeit am Drehbuch mit Ernest Lehman Der unsichtbare Dritte ging diesmal nicht mehr so reibungslos vonstatten Hitchcock war merklich müde geworden seine körperlichen Schmerzen betäubte er zunehmend mit Alkohol
Zwei Jahre benötigte die Fertigstellung des Drehbuchs so lange wie nie zuvor in seiner Karriere
Mit
Familiengrab wie der Film schließlich hieß kehrte Hitchcock zum scheinbar heiteren diesmal jedoch morbid akzentuierten Unterhaltungsthriller zurück
Wie stets legte er Wert auf eine ausgeklügelte Bildsprache die erneut mit Hilfe von Storyboards erarbeitet wurde Die Dreharbeiten gestalteten sich reibungslos und in einer entspannten Atmosphäre
Hitchcock der sich im Rahmen seiner gesundheitlichen Möglichkeiten mit einem lange nicht gezeigten Elan in die Dreharbeiten einbrachte zeigte sich zu Neuerungen bereit Er war offen für Improvisationen seiner Schauspieler und nahm noch während der Dreharbeiten Änderungen am Ablauf vor
Die Überwachung der Schnittarbeiten musste er weitgehend seinen Mitarbeiterinnen Peggy Robertson und Suzanne Gauthier überlassen da sich sein Gesundheitszustand deutlich verschlechterte
Zudem erlitt Alma einen zweiten Schlaganfall
Familiengrab wurde nach seiner Premiere im Frühjahr <num> überwiegend freundlich aufgenommen und Hitchcock schöpfte aus der Sympathie die ihm entgegenschlug für kurze Zeit Kraft neue Filmideen aufzugreifen
Sein erst Anfang <num> in Angriff genommenes Projekt die Verfilmung des Romans The Short Night von Ronald Kirkbride wurde aufgrund seines sich weiter verschlechternden Gesundheitszustands jedoch etwa ein Jahr später von Universal gestoppt
Im März <num> wurde er vom American Film Institute für sein Lebenswerk geehrt
Zwei Monate später schloss er sein Büro auf dem Gelände der Universal-Studios
Am <num> Januar <num> wurde Hitchcock in den britischen Adelsstand erhoben
Am Morgen des <num> April <num> starb Alfred Hitchcock in seinem Haus in Los Angeles an Nierenversagen
Seine Leiche wurde eingeäschert die Asche an einem unbekannten Ort verstreut
Inhalte und Formen
In rund fünfzig Jahren hat Alfred Hitchcock dreiundfünfzig Spielfilme als Regisseur begonnen und beendet
Die weitaus größte Zahl dieser Filme gehört dem Genre des Thrillers an und weist ähnliche Erzählmuster und Motive auf wiederkehrende Elemente visuelle Stilmittel und Effekte die sich wie ein roter Faden durch sein Gesamtwerk ziehen
Inhalt
Motive
Das Grundmotiv in Hitchcocks Filmen bildet meist die Angst der Protagonisten vor der Vernichtung ihrer bürgerlichen Existenz
Dabei bezieht sich diese Angst nicht nur auf Mörder Gangster oder Spione welche die bürgerliche Ordnung angreifen die Hauptfiguren finden sich häufig in der Lage wieder sogar von Vertretern des Gesetzes bedroht zu werden
Zu diesem Motiv der Angst kommt - Hitchcocks katholischer Prägung entsprechend - jenes von Schuld und Sühne hinzu
Der unschuldig Verfolgte in seinen Filmen ist unschuldig aber nur in Bezug auf das was man ihm vorwirft Das heißt die Figur wird durch das was ihr im Laufe des Filmes widerfährt im übertragenen Sinne für andere Defizite oder Vergehen bestraft In Bei Anruf Mord etwa wird die Hauptfigur des Mordes verdächtigt tatsächlich musste sie aus Notwehr töten
Das folgende Unheil kann jedoch als Strafe für den von ihr begangenen Ehebruch angesehen werden
Eine Variation dieses Themas ist die Übertragung der Schuld auf eine andere Person
Unschuldige werden zu Schuldigen oder Mitschuldigen an Verbrechen anderer da sie aus persönlichen Gründen nicht zur Aufklärung beitragen können
Zentral sind hierbei die beiden Filme Ich beichte und Der Fremde im Zug in denen die jeweiligen Protagonisten von Morden die andere begangen haben profitieren und nachdem sie selbst unter Verdacht geraten keine Möglichkeit haben sich zu entlasten
In Vertigo macht der wahre Mörder die Hauptfigur durch ein Komplott zunächst scheinbar zum Schuldigen am Tod der ihr anvertrauten Person
Später macht sich das Opfer der Intrige tatsächlich am Tod der Frau schuldig die er liebt
Falsche Verdächtigungen aber auch ausgeprägte Schuldkomplexe gehen bei Hitchcocks Filmen mit der Bedrohung der Identität einher
Seine traumatisierten oder verfolgten Figuren nehmen selbst falsche Namen an oder werden - aus unbekannten Gründen - für jemand anderen gehalten
Das Motiv des Identitätsverlusts spielt Hitchcock angefangen von seinem ersten bis zu seinem letzten Film in unterschiedlichsten Varianten durch besonders einprägsam in Vertigo Die weibliche Hauptfigur wird zunächst im Rahmen eines Mordkomplotts in eine andere Person die anschließend ermordet wird verwandelt und nimmt daraufhin wieder ihre eigentliche Identität an nur um anschließend wieder in die andere Person zurückverwandelt zu werden
Oft stehen Schuld und Bedrohung in Zusammenhang mit sexuellen Aspekten
In Der Fall Paradin genügt bereits der Gedanke an Ehebruch um das Leben des Protagonisten zu gefährden
In Berüchtigt ist der Zusammenhang zwischen Sex Schuld und Bedrohung zentrales Thema
Hitchcocks Verbindung von Sex und Gewalt wird in Mordszenen deutlich die er oft wie Vergewaltigungen inszeniert etwa der Schlusskampf zwischen Onkel und Nichte Charlie in Im Schatten des Zweifels die Scherenszene in Bei Anruf Mord und die Duschszene in Psycho
Darüber hinaus spielt Sexualität gerade in abnorm empfundenen Erscheinungsformen eine große Rolle in seinem Werk
Aufgrund der Auflagen der Zensur werden jedoch Homosexualität die in Verbindung mit Schuld und Verderben regelmäßig vorkommt oder Nekrophilie in Vertigo nur in einzelnen Gesten oder Schlüsselszenen angedeutet Auch Fetischismus Erpressung Vertigo Psycho und Voyeurismus Das Fenster zum Hof Psycho spielen in seinen Filmen eine gewisse Rolle
In mehreren Filmen wird zudem ein erotischer Bezug der männlichen Hauptfiguren zu ihren Müttern angedeutet etwa in Psycho und Die Vögel Zentral in diesem Zusammenhang ist Berüchtigt
Hier verhalten sich Claude Rains und Leopoldine Konstantin in manchen Schlüsselszenen wie ein Ehepaar
Dieser Eindruck wird durch den geringen Altersunterschied der Schauspieler von nur vier Jahren verstärkt
Unter den in Hitchcocks Bildsprache verwendeten Symbolen finden sich Vögel als Vorboten des Unglücks etwa in Erpressung später als vorherrschendes Thema in Die Vögel Treppen die Verlust oder Freiheit bedeuten können Berüchtigt Psycho Vertigo und andere sowie Handschellen und andere Fesseln um Abhängigkeit und Ausgeliefertsein auszudrücken meist im sexuellen Kontext zum Beispiel in Der Mieter Auch Spiegel tauchen bei Hitchcock regelmäßig auf - in Zusammenhang mit dem Verlust oder der Erkenntnis der eigenen Persönlichkeit oder als allgemeines Symbol für Täuschungen einprägende Beispiele Vertigo und Psycho
Figuren
Die meisten Protagonisten in Hitchcocks Thrillern sind Normalbürger die zu Beginn der Geschichte in der Regel nichts mit kriminellen Machenschaften zu tun haben
Meist werden sie durch Zufall oder unbekannte Umstände in geheimnisvolle und bedrohliche Vorgänge gezogen
Dem Zuschauer wird so das beunruhigende Gefühl vermittelt dass auch er jederzeit in derartige Situationen geraten könnte
Professionelle Agenten oder Spione findet man dagegen nur selten unter den Hauptfiguren obwohl Hitchcock viele Filme drehte die im Agentenmilieu spielen
Hitchcock drehte bis auf eine Ausnahme Erpressung <num> auch nie einen Film in dem die Arbeit der Polizei im Mittelpunkt steht aktive Polizisten tauchen ansonsten nur als Nebenfiguren und üblicherweise als Hindernis auf
Männliche Antihelden
Der Prototyp des Antihelden bei Hitchcock sind die von James Stewart gespielten Figuren In Cocktail für eine Leiche muss der von Stewart dargestellte Lehrer erkennen dass zwei seiner Studenten eine seiner Theorien zum Anlass nahmen einen Mord zu verüben und diesen mit seinen Thesen zu rechtfertigen am Ende steht er hilflos vor diesem menschlichen Abgrund in den er nicht nur hineingezogen wurde sondern den er sogar mit heraufbeschworen hat
In Das Fenster zum Hof stellt Stewart eine Figur dar die bindungsscheu sowie körperlich beeinträchtigt und voyeuristisch veranlagt ist und dadurch in Schwierigkeiten kommt
Es gibt nur wenige positive ungebrochene Helden bei Hitchcock
Ein Schauspieler der diesen seltenen Rollentypus verkörperte war Cary Grant in Über den Dächern von Nizza und in Der unsichtbare Dritte
Diese Figuren meistern die Herausforderungen zwar mit Charme und Leichtigkeit doch stehen sie in Verdacht kriminell zu sein beziehungsweise verlieren sie zeitweise die Kontrolle womit selbst sie keine gänzlich unantastbaren Helden sein können
Aber sogar Cary Grant spielt in zwei seiner Hitchcock-Filme Figuren deren Schattenseiten sich zeitweise vor deren positive Merkmale schieben
Im Laufe der Karriere Hitchcocks gewinnen ambivalente oder gar negativ gezeichnete Hauptfiguren immer stärker an Gewicht
Diese Antihelden weisen physische oder psychische Probleme auf sind Verlierertypen oder unsympathisch
Durch ihr obsessives Fehlverhalten wirken sie schwach und können Schaden anrichten
Diese Figuren dienen zwar kaum als Vorbild doch soll deren ambivalente Persönlichkeit dazu beitragen dass sich der Zuschauer in ihnen wiederfinden kann
Starke Frauen
In vielen Filmen bedient Hitchcock auf den ersten Blick das klassische Motiv der schwachen zu beschützenden Frau
Doch während das Klischee verlangt dass der strahlende Held sie rettet ist sie bei Hitchcock oft auf sich alleine gestellt
In einigen Fällen ist der vermeintliche Beschützer schwach oder zu sehr mit sich selbst beschäftigt als dass er der bedrohten Frau helfen könnte wie zum Beispiel Ingrid Bergman und Cary Grant in Berüchtigt
In anderen Fällen geht von der männlichen Hauptfigur in der Regel dem Ehemann sogar ein tatsächliches oder vermeintliches Bedrohungspotential aus
Klassische Beispiele Joan Fontaine und Cary Grant in Verdacht sowie Grace Kelly und Ray Milland in Bei Anruf Mord
Die Rollenverteilung zwischen Mann und Frau kehrt Hitchcock in einigen Filmen gänzlich um Die Frau ist dem Mann der zunehmend passiver wird überlegen und wendet das Geschehen zum Guten
Beispiele sind Jung und unschuldig die Tochter des Polizeichefs verhilft einem Verdächtigen zur Flucht und löst letztendlich den Fall Ich kämpfe um dich eine Psychologin dringt in das Unterbewusste des Mordverdächtigen ein und rettet ihn vor der sicheren Verurteilung sowie Der Mann der zuviel wußte die Ehefrau verhindert zuerst einen geplanten Mord und rettet dann das eigene Kind vor den Verbrechern
Der Typ der sich dabei im Laufe der Zeit herauskristallisierte ist jener der jungen schönen kühlen hintergründigen und undurchsichtigen Blondine Die oberflächliche Kühle der Hitchcock-Blondine verbirgt jedoch eine stark entwickelte Sexualität
Besonders deutlich wird dies in Der unsichtbare Dritte wenn Eva Marie Saint zunächst gegenüber Cary Grant zweideutige Bemerkungen macht dann plötzlich den völlig überraschten Fremden küsst und ihn ohne Zögern in ihrem Schlafwagenabteil unterbringt
Nicht der Mann sondern die blonde Frau spielt hier den aktiven Part und zeigt damit die Fragilität des männlichen bürgerlichen Weltbildes
Sympathische Schurken
Hitchcock legt durch seine Gestaltung von Figuren und Dramaturgie dem Zuschauer eine Identifikation mit dem Schurken nahe
Seine Antagonisten wirken zuweilen auffällig sympathisch und übertreffen mitunter die Ausstrahlung der Hauptfiguren
Oft konkurrieren Held und Bösewicht um dieselbe Frau die Liebe des Gegenspielers erscheint dabei tiefer und aufrichtiger als die des Helden
Besonders auffällig ist dies in Berüchtigt Claude Rains gegenüber Cary Grant und in Der unsichtbare Dritte James Mason wiederum gegenüber Cary Grant
Selbst ein ausgesprochen heimtückischer Schurke wie Ray Milland in Bei Anruf Mord wirkt in einzelnen Momenten gegenüber dem unbeholfenen Robert Cummings sympathischer in jedem Fall jedoch gegenüber der Polizei vertrauenserweckender
Oft sind sie die eigentlichen Hauptfiguren wie Joseph Cotten als charmanter Witwenmörder in Im Schatten des Zweifels oder Anthony Perkins als linkischer von seiner Mutter gepeinigter Mörder in Psycho
Dominante Mütter
In vielen seiner Filme - ab Mitte der <num>er Jahre regelmäßig - tauchen dominante Mütter auf die einen beunruhigenden Einfluss auf ihre meist erwachsenen Kinder ausüben und zum Teil Auslöser oder Ursache dramatischer Ereignisse sind
Erstmals uneingeschränkt bösartig erscheint die Mutter in Berüchtigt <num> die ihren Sohn zum Mord an der Frau die er liebt antreibt
Der extremste Fall tritt in Psycho <num> zutage wo die tote Mutter noch von ihrem Sohn Besitz ergreift und ihn zu ihrem mordenden Werkzeug werden lässt
Daneben gibt es eine Vielzahl weniger dämonischer Variationen wobei Besitzergreifung allen Mutter-Typen gemein ist In Die Vögel <num> erträgt es die Mutter von Mitch Jessica Tandy nicht dass ihr erwachsener Sohn Rod Taylor sich für eine andere Frau interessiert
In Marnie <num> wird das Leben der Tochter durch einen von der Mutter übertragenen Schuldkomplex beinahe zerstört
In zwei Filmen variiert Hitchcock dieses Rollenmuster In Rebecca und Sklavin des Herzens übernehmen Haushälterinnen die Funktion der dämonischen Mutter
Zwielichtige oder leichtgläubige Beamte
Üblicherweise positiv besetzte Figuren wie Polizisten Richter oder andere Vertreter des Staates erscheinen oft zwiespältig Sie sind nicht in der Lage die Helden zu beschützen oder stellen sogar eine Bedrohung für diese dar
Polizisten verdrehen das Recht sie handeln aus persönlichen Motiven sie glauben dem ersten Anschein und schützen den tatsächlich Schuldigen aufgrund von dessen vordergründig tadellosem Erscheinen sie sind tollpatschig oder arbeiten schlampig
Dieses Rollenmuster durchzieht Hitchcocks gesamtes Werk von Der Mieter <num> bis Frenzy <num>
Darüber hinaus finden sich vereinzelt Geheimdienstmitarbeiter unter den Nebenfiguren die sich als Gegner das Ehepaar Drayton in Der Mann der zuviel wußte <num> oder als Helfer offenbaren wobei auch letztere Schwierigkeiten bringen können - beispielsweise der General Peter Lorre in Geheimagent oder Leo G Carroll als CIA-Mitarbeiter in Der unsichtbare Dritte
Indem die feste Trennlinie zwischen Gut und Böse verschwimmt wird das Gefühl der Verunsicherung beim Zuschauer gesteigert
Formale Elemente
Dramaturgie
Hitchcocks Credo lautete For me the cinema is not a slice of life but a piece of cake etwa Für mich ist das Kino nicht ein Stück aus dem Leben sondern ein Kinderspiel Film war für ihn eine artifizielle Kunstform
Nur einmal - in Der falsche Mann - wich er von diesem Grundsatz ab
Aber auch hier liegt der Akzent auf jenen Elementen die nicht dokumentarisch sind - etwa der subjektiven Perspektive des unschuldig Verdächtigten und seiner hilflosen Frau
Einigen seiner weiteren Filme liegen zwar auch reale Ereignisse zugrunde Der zerrissene Vorhang Das Fenster zum Hof Der Auslandskorrespondent oder Cocktail für eine Leiche doch werden diese so weit fiktionalisiert dass außer dem Grundmotiv kein Bezug zu der ursprünglichen Geschichte übrig bleibt
Eine nicht verwirklichte Idee für Der unsichtbare Dritte die der Regisseur im Interview mit Truffaut erwähnt verdeutlicht Hitchcocks Vorstellungen davon die Realität zu transzendieren Er wollte zeigen wie unter den Augen Cary Grants auf einem Fließband ein Auto zusammengebaut wird und anschließend aus dem fertiggestellten Auto eine Leiche fällt - nach realistischen Maßstäben unmöglich
Doch Hitchcocks Begründung für das Verwerfen der Idee zeigt dass er sich in solchen Fragen nicht an der Wahrscheinlichkeit orientierte Wir haben die Idee in der Geschichte nicht richtig unterbringen können und selbst eine willkürliche Szene kann man nicht ohne Motiv ausführen Den Vorwurf Gesetze der Plausibilität zu missachten nahm er bewusst in Kauf Wenn man alles analysieren wollte und alles nach Erwägungen der Glaubwürdigkeit und Wahrscheinlichkeit konstruieren dann würde keine Spielfilmhandlung dieser Analyse standhalten und es bliebe einem nur noch eines übrig Dokumentarfilme zu drehen Hitchcock vertraute darauf dass die Zuschauer unwahrscheinliche Details akzeptieren würden da er diese nur verwendete um die Handlung zu dramatisieren voranzutreiben oder zu straffen
Für bewusste Irritation sorgte auch Hitchcocks Spiel mit filmtypischen Klischees
So vermied er es insbesondere bei den Nebenrollen Schauspieler nach festgelegtem Typ zu besetzen
Auch bei der Wahl seiner Spielorte entzog sich Hitchcock den Genre-Gesetzen
So ließ er Verbrechen und bedrohliche Szenen häufig nicht in unheimlichen dunklen Räumen stattfinden sondern bei hellem Tageslicht und an scheinbar harmlosen Orten wie einem mit Menschen übersäten Marktplatz Der Mann der zuviel wußte <num> und Der Auslandskorrespondent in einer menschenleeren Landschaft auf einer öffentlichen Versteigerung und in einer Hotelhalle Der unsichtbare Dritte auf einer idyllischen Bergstraße Über den Dächern von Nizza auf einer Party Berüchtigt und Jung und unschuldig in einer voll besetzten Konzerthalle beide Der Mann der zuviel wußte oder in einem mit lauter freundlichen Menschen besetzten Eisenbahnzug Eine Dame verschwindet
Suspense
Die klassische auf das Überraschungsmoment aufbauende Form des Kriminalfilms ist der Whodunit
Bis auf wenige Ausnahmen bediente sich Hitchcock jedoch einer anderen Form des Spannungsaufbaus des sogenannten Suspense Dem Zuschauer sind ab einem gewissen Zeitpunkt bestimmte Informationen oder Umstände bekannt von denen die handelnden Personen nichts wissen
Er fiebert in besonderer Weise mit den Helden er sieht Ereignisse kommen möchte den Figuren helfen kann es aber nicht
In einigen Filmen wird das klassische Suspense dahingehend variiert dass handelnde Personen die Rolle des Zuschauers übernehmen
Ein Beispiel von vielen In Das Fenster zum Hof dringt Lisa in die Wohnung des verdächtigen Nachbarn ein um nach Beweisen für einen möglichen Mord zu suchen
Ihr Partner Jeff beobachtet das Geschehen von der gegenüber liegenden Wohnung aus und sieht dabei den Nachbarn vorzeitig zurückkommen
Er vermutet sie in Lebensgefahr kann ihr aber nicht helfen
Für einige markante Szenen baute Hitchcock zudem bewusst eine Suspense-Situation auf um den Zuschauer mit einem umso gewaltigeren Überraschungseffekt schockieren zu können
Ein berühmtes Beispiel findet sich in Psycho Zum einen ist Marion Crane mit verschiedenen Insignien einer typischen Hauptfigur eines Hitchcockfilms ausgestattet so dass kaum jemand erwartet dass sie bereits in der ersten Hälfte des Films stirbt
Zum anderen schaltet Hitchcock der Duschszene selbst einen Suspense-Moment vor
Norman Bates beobachtet Marion Crane durch ein Loch in der Wand beim Entkleiden
Sie geht unter die Dusche
Der Zuschauer wird nun eben keinen Mord sondern schlimmstenfalls eine Vergewaltigung durch Norman befürchten
Der bestialische Mord ist somit völlig überraschend und damit ein Grund für die Berühmtheit der Szene
MacGuffin
Ein von Hitchcock in seinen Thrillern sehr häufig verwendetes Mittel war der sogenannte MacGuffin ein Element das die Handlung vorantreibt oder sogar initiiert obwohl es für die Entwicklung der Figuren und für den Zuschauer inhaltlich völlig bedeutungslos geradezu austauschbar ist
Der MacGuffin in Der unsichtbare Dritte sind schlicht Regierungsgeheimnisse über die der Held oder der Zuschauer während der gesamten Handlung nichts Weiteres erfährt
In Psycho benutzt Hitchcock unterschlagenes Geld das die Sekretärin zur Flucht treibt und so in Bates Motel führt um das Publikum anfangs gezielt in die Irre zu führen und für einen Kriminalfall zu interessieren der mit der eigentlichen Handlung nur am Rande zu tun hat
Die mysteriösen <num> Stufen im gleichnamigen Film sind eine Geheimorganisation über die bis kurz vor Ende des Films überhaupt nichts bekannt ist außer dass sie gefährlich ist
Ein besonders außergewöhnlicher MacGuffin ist die als Volksliedmelodie getarnte Geheimdienstinformation aus
Eine Dame verschwindet
Filmische Mittel
Beeinflusst vom Stummfilm beruhte Hitchcocks Filmverständnis auf dem Anspruch alles Wichtige in seinen Filmen visuell und so wenig wie möglich durch Dialoge auszudrücken
Seine typischen Kameraeinstellungen geben im Bild genau das wieder was für das Verständnis der Szene wesentlich ist - auch um dem Zuschauer nicht die Möglichkeit zu geben sich durch unwesentliche Details ablenken zu lassen
So wirken beispielsweise Kuss-Szenen bei Hitchcock immer sehr intim da er gewöhnlich mit der Kamera sehr nahe an die beiden sich Küssenden heranfuhr und den Zuschauer sozusagen zum dritten Umarmenden machte Zu den berühmtesten Beispielen dieser visuellen Erzählweise zählen die Duschszene aus Psycho der Flugzeugangriff auf Cary Grant und die Jagd auf Mount Rushmore in Der unsichtbare Dritte die Versammlung der Vögel auf dem Klettergerüst in Die Vögel oder die zehnminütige Konzertszene in der Royal Albert Hall in Der Mann der zuviel wußte von <num>
Hitchcocks visueller Arbeitsstil drückt sich unter anderem in den Expositionen vieler seiner Filme aus
Er bringt den Zuschauern die handelnden Figuren und die Umstände der folgenden Handlung ohne die Verwendung von Dialogen nahe
Die Länge dieser Einführungen variiert zwischen wenigen Sekunden und mehreren Minuten
Erstmals verfolgte Hitchcock diese Technik <num> in seinem ersten Tonfilm Erpressung
Zudem tauchen in Hitchcocks Filmen immer wieder ungewöhnliche filmische Operationen auf um die Stimmung und Spannung bewusst zu verstärken beispielsweise eine gegenläufige Zoom-Fahrtbewegung in Vertigo später auch als Vertigo-Effekt bezeichnet lange Kamerafahrten wie die aus einer Totale eines großen Raums bis in die Naheinstellung eines Schlüssels in einer Hand in Berüchtigt oder auf ein zuckendes Auge in Jung und unschuldig sowie die aus ungefähr siebzig Einstellungen bestehende fünfundvierzig Sekunden lange Mordszene unter der Dusche in Psycho unmittelbar gefolgt von einer etwa einminütigen Kamerafahrt ohne einen einzigen Schnitt
Der Production Designer Robert Boyle mit dem Hitchcock bei fünf Filmen zusammenarbeitete meinte Keiner der Regisseure mit denen ich je zusammengearbeitet habe wusste so viel über Film wie er
Viele der Regisseure mit denen ich gearbeitet habe wussten eine ganze Menge aber sie besaßen nicht die technischen Fähigkeiten die er hatte
Er suchte immer nur den visuellen Ausdruck und so etwas wie eine zufällige Einstellung gab es bei ihm nicht
Nur einmal griff Hitchcock aus Experimentierfreude auf einen filmtechnischen Kniff zurück der sich nicht unmittelbar aus der Dramaturgie ergab
In Cocktail für eine Leiche <num> drehte er bis zu zehn Minuten lange Einstellungen die er zum großen Teil sogar über unsichtbare Schnitte ineinander übergehen ließ
Er wollte damit bei dieser Theaterverfilmung die Einheit von Zeit und Raum dokumentieren
Später gab er zu dass es ein Fehler war damit gleichzeitig den Schnitt als wesentliches gestaltendes Instrument der Dramaturgie aus der Hand gegeben zu haben
Licht und Farben
Inspiriert von amerikanischen und deutschen Filmemachern setzte Hitchcock schon bei seinen ersten Filmen Licht- beziehungsweise Schatteneffekte ein
Typisch für Hitchcock sind Linien und Streifen in Form von Schatten durch Gitter Jalousien oder Ähnliches verursacht die vor allem auf Gesichter fallen und eine unheilvolle Atmosphäre verstärken sollen
Darüber hinaus verwendet er in einzelnen Szenen sehr starke zum Teil unnatürlich wirkende Kontraste um einen äußeren oder inneren Gut-Böse-Gegensatz zu visualisieren
Dieses Hell-Dunkel-Spiel unterstützte Hitchcock durch die Kostüme der Figuren
So ließ er Ingrid Bergman am Anfang von Berüchtigt gestreifte Kleidung tragen um ihre Zerrissenheit zu unterstreichen
In Der Mieter trug Ivor Novello zu Beginn Schwarz später um seine Unschuld auch nach außen hin deutlich zu machen Weiß
Die Methode durch die Farbgebung der Kostüme den emotionalen Zustand der Figuren zu unterstreichen behielt Hitchcock auch für die Farbfilme bei
In Bei Anruf Mord wurden die Kostüme von Grace Kelly mit der Dauer des Films immer trister und grauer entsprechend ihrer inneren Gemütsverfassung
Zu Hitchcocks Farbwahl von Grace Kellys Kleidern in Das Fenster zum Hof sagte die Kostümbildnerin Edith Head Für jede Farbe und jeden Stil gab es einen Grund er war sich seiner ganzen Entscheidung absolut sicher
In einer Szene sah er sie in blassem Grün in einer anderen in weißem Chiffon in einer weiteren in Gold
Er stellte im Studio tatsächlich einen Traum zusammen In seinen späteren Filmen allen voran Marnie und Vertigo gab es eine ausgefeilte die Kostüme die Dekors und die Beleuchtung umfassende Farbdramaturgie
Tricktechnik
Nach Hitchcocks Filmverständnis schafft sich der Film seine eigene Realität und soll oder darf kein Abbild des wahren Lebens sein
Die Nutzung sämtlicher Möglichkeiten genau das wiederzugeben was der Regisseur sich vorstellt ist nach diesem Verständnis nicht nur legitim sondern erforderlich
Hitchcock hat die Entwicklung der Tricktechnik aufmerksam beobachtet und schon sehr früh - gelegentlich zum Missfallen seiner Produzenten - neue Trickverfahren eingesetzt zum Beispiel das Schüfftan-Verfahren in Erpressung oder das Matte Painting
In seinen englischen Thrillern vor allem in Nummer siebzehn und Jung und unschuldig arbeitete Hitchcock bei Verfolgungsjagden oft und erkennbar mit Modellen
In Eine Dame verschwindet sind die Rückprojektionen während der Zugfahrt aber bereits so ausgereift dass sie noch Jahrzehnte später überzeugen
Ähnliches gilt für die Schlussszene von Der Fremde im Zug in der zwei Männer auf einem sich immer schneller drehenden Karussell kämpfen - in einer virtuosen Kombination von Realeinstellungen Modellen und Rückprojektionen
Die Vögel <num> beinhaltet rund vierhundert Trickeinstellungen für die Hitchcock auf sämtliche damals verfügbaren Tricktechniken zurückgriff unter anderem auch auf das ansonsten für Animationsfilme verwendete Rotoskopieverfahren
Ton und Musik
Hitchcock hat seit dem Aufkommen des Tonfilms Musik und Toneffekte eingesetzt um die Dramaturgie bewusst zu unterstützen
Den Umgang Hitchcocks mit dem Medium Ton beschrieb die Schauspielerin Teresa Wright Im Schatten des Zweifels folgendermaßen Wenn ein Schauspieler mit den Fingern trommelte war das nicht ein zweckloses Trommeln es hatte einen Rhythmus ein musikalisches Muster - es war wie ein Geräusch-Refrain
Ob jemand nun ging oder mit Papier raschelte oder einen Umschlag zerriss oder vor sich hin pfiff ob das Flattern von Vögeln oder ein Geräusch von draußen war alles wurde sorgfältig von ihm orchestriert
Er komponierte die Toneffekte wie ein Musiker Instrumentenstimmen Gegenüber Truffaut erwähnte Hitchcock dass er nach dem Endschnitt eines Films seiner Sekretärin ein Tondrehbuch diktiert das alle von ihm gewünschten Geräusche enthält
In Mord - Sir John greift ein <num> versteckte Hitchcock da ein nachträgliches Bearbeiten der Tonspur zu diesem Zeitpunkt technisch noch nicht möglich war gar ein komplettes Orchester hinter den Kulissen um die entsprechenden Stellen musikalisch zu untermalen
Weitere klassische Beispiele für Hitchcocks dramaturgischen Musikeinsatz sind Geheimagent <num> der Dauerakkord des toten Organisten in der Kirche Eine Dame verschwindet <num> die Melodie mit dem Geheimcode und der Volkstanz Im Schatten des Zweifels <num> der Merry-Widow-Walzer Der Fremde im Zug <num> die Szenen auf dem Rummelplatz und Das Fenster zum Hof <num> die im Laufe des Films entstehende Komposition des Klavierspielers
In Der Mann der zuviel wußte <num> schließlich wird Musik sowohl orchestral wie auch gesungen aktiv inszeniert und dramaturgisch eingebunden Sie spielt eine wesentliche Rolle in der Gesamtdramaturgie des Films
Die Musik der Filme aus den späten <num>er und frühen <num>er Jahren der Zeit als Hitchcock mit dem Komponisten Bernard Herrmann zusammenarbeitete ist tragendes Element der jeweiligen Filme
Kritiker bescheinigen der Musik der Filme Vertigo Der unsichtbare Dritte und Psycho sowie den Toneffekten von Oskar Sala zu Die Vögel wesentlich zum jeweiligen Gesamteindruck des Films beizutragen
Prägende Einflüsse
Vorbilder
Hitchcock war beeindruckt von den Filmen die er in seiner Jugend und in seinen frühen Jahren im Filmgeschäft sah etwa jenen von D W Griffith Charlie Chaplin Buster Keaton und Douglas Fairbanks senior
Als Stummfilmregisseur in England übernahm er vom US-Film unter anderem die Technik mit Hilfe von Beleuchtungseffekten Tiefe zu schaffen und den Vorder- vom Hintergrund abzusetzen was bis in die <num>er Jahre im britischen Film unüblich war
Angetan war er auch von den deutschen Stummfilmregisseuren wie Fritz Lang und Ernst Lubitsch
F W Murnaus Der letzte Mann
dessen Dreharbeiten Hitchcock <num> in München beobachtete bezeichnete er später als den fast perfekten Film Er erzählte seine Geschichte ohne Titel von Anfang bis Ende vertraute er ganz auf seine Bilder
Das hatte damals einen ungeheueren Einfluss auf meine Arbeit Einfluss auf Hitchcocks Arbeit hatte auch
Das Cabinet des Dr Caligari
den Robert Wiene <num> drehte Die Betonung des Visuellen im deutschen Expressionismus prägte seinen eigenen Umgang mit filmischen Mitteln
Abgesehen von diesen stilistischen Einflüssen vermied es Hitchcock jedoch Szenen oder Einstellungen bekannter Filme zu zitieren
Als Ausnahme kann
Panzerkreuzer Potemkin
<num> des sowjetischen Regisseurs Eisenstein angesehen werden
In Die <num> Stufen Über den Dächern von Nizza und einigen weiteren Filmen erinnern die vor Entsetzen schreienden Frauen an Einstellungen aus der berühmten und oft zitierten Szene an der Hafentreppe in Odessa
Es gibt außerdem in Hitchcocks Werk aus den <num>er und <num>er Jahren einige motivische und visuelle Überschneidungen mit der Gattung des Film noir die den amerikanischen Kriminalfilm in jener Zeit bestimmte etwa in Im Schatten des Zweifels und Berüchtigt und besonders in Der falsche Mann wo das Motiv der allgegenwärtigen Bedrohung der Hauptfiguren eine Rolle spielt
Darüber hinaus bediente er sich gerne einer ähnlich kontrastreichen Bildgestaltung die er sich in den Grundzügen allerdings bereits in den <num>er Jahren angeeignet hatte
Auch Vertigo erinnert in der Grundkonstellation und der alptraumhaften Zwanghaftigkeit der Geschehnisse an einige Filme des Genres wie zum Beispiel Frau ohne Gewissen hebt sich jedoch formal und stilistisch deutlich vom Film noir ab
Als typischer Vertreter des Genres kann Hitchcock jedenfalls nicht angesehen werden
Obsessionen
Seine Vorliebe für Blondinen erklärte Hitchcock gegenüber Truffaut wie folgt Ich finde die englischen Frauen die Schwedinnen die Norddeutschen und die Skandinavierinnen sind interessanter als die romanischen die Italienerinnen und die Französinnen
Der Sex darf nicht gleich ins Auge stechen
Eine junge Engländerin mag daherkommen wie eine Lehrerin aber wenn Sie mit ihr in ein Taxi steigen überrascht sie Sie damit dass sie Ihnen in den Hosenschlitz greift Ähnlich äußerte er sich <num> gegenüber Look über die Truffaut-Schauspielerin Claude Jade die bei ihm in Topaz gespielt hatte Claude Jade ist eine eher ruhige junge Dame doch für ihr Benehmen auf dem Rücksitz eines Taxis würde ich keine Garantie übernehmen
Dass Hitchcock zu seinen jungen blonden Schauspielerinnen ein besonderes Verhältnis hatte und ihnen mehr Aufmerksamkeit widmete als allen anderen war schon früh bekannt
Die Sorgfalt mit der Hitchcock bereits in den <num>er und <num>er Jahren Madeleine Carroll Carole Lombard und insbesondere Ingrid Bergman in Szene setzte entwickelte sich mit der Zeit zu einer sich steigernden Verquickung privater und beruflicher Interessen die sich zu einer Obsession ausweitete
Mit Vera Miles probte er die Nervenzusammenbrüche welche sie in Der falsche Mann darstellen sollte wochenlang jeweils mehrere Stunden täglich Für sie wie für Kim Novak ließ er von der Kostümbildnerin eine komplette Garderobe schneidern die für ihr privates Leben gedacht war
Tippi Hedren Die Vögel ließ er sogar von zwei Crew-Mitgliedern beschatten und begann ihr Vorschriften für ihr Verhalten im Privatleben zu machen
Diese Vereinnahmung hatte ihren Höhepunkt in sich über Tage hinziehenden Aufnahmen von auf sie einstürzenden echten Vögeln Nach einem eindeutigen erfolglosen Annäherungsversuch während der Arbeiten zu Marnie kam es schließlich zum Bruch
Die zuvor offen bekundete Zuneigung schlug ins Gegenteil um und Hitchcock ließ keine Gelegenheit aus Tippi Hedren bei anderen herabzusetzen
Sie blieb die letzte typische Hitchcock-Blondine Zwar hielt sich Hitchcock darüber stets äußerst bedeckt doch es gilt als gesichert dass der Regisseur sich von diesen Schwierigkeiten lange nicht erholen konnte und in seiner kreativen Schaffenskraft beeinträchtigt war
Ebenso gelten Filme wie Vertigo und Berüchtigt aber auch Marnie oder Im Schatten des Zweifels die von neurotischen Männern handeln die Frauen manipulieren als stark autobiographisch
Auch die Verbindung zwischen Sex und Gewalt faszinierte Hitchcock was vor allem in seinen späteren Werken immer deutlicher zutage tritt
Mehrfach inszenierte er vollendete oder versuchte Vergewaltigungen schon früh in Erpressung später dann in Marnie und Frenzy
In drei nicht realisierten Projekten sollten Vergewaltiger oder Vergewaltigungen eine zentrale Rolle spielen Morde inszenierte er einige Male als Vergewaltigungen mit dem Messer als Phallus-Symbol
Doch auch der Tod durch Erwürgen oder Strangulieren übte eine gewisse Faszination auf ihn aus
Einige Würgeszenen gehören zu den bemerkenswertesten Mordszenen seiner Karriere etwa in Cocktail für eine Leiche Bei Anruf Mord Der zerrissene Vorhang und Frenzy Sich selbst ließ er oft in Würgerposen ablichten
Ähnlich offen kokettierte Hitchcock zeit seines Lebens mit seiner panischen Angst vor der Polizei
Hitchcock erzählte gerne dass er mit fünf Jahren nachdem er etwas angestellt hatte von seinem Vater mit einem Zettel auf das nahegelegene Polizeirevier geschickt worden sei
Der Polizist las den Zettel und sperrte Alfred für fünf oder zehn Minuten in eine Zelle mit dem Kommentar dies würde die Polizei mit ungezogenen Jungen so machen
In seinen Filmen geht von Polizisten stets eine latente Gefahr aus
Zu der Frage inwieweit das von Hitchcock in seinen Filmen transportierte Bild der besitzergreifenden Mutter von der eigenen Mutter geprägt ist gab es von ihm selbst keinerlei Aussagen
Das wenige was man aus seiner Kindheit weiß legt jedoch autobiographische Ursprünge nahe Hitchcocks Mutter starb nach langer Krankheit im August <num> während der Dreharbeiten zu Im Schatten des Zweifels
Dieser bereits von vornherein stark autobiographisch geprägte Film nimmt eindeutig Bezug auf Hitchcocks Verhältnis zu ihr Der Name Emma scheint nicht die einzige Gemeinsamkeit zwischen ihr und der dominanten Mutterfigur im Film zu sein
Zudem ist im Film noch von einer anderen gebieterischen jedoch kranken Mutter die Rede - jener des Krimi-Besessenen Herb Hawkins der wiederum als Selbstprojektion Hitchcocks gilt
Auffallend oft sind Toiletten in Hitchcocks Filmen zu sehen oder zu hören in denen konspirative Dinge irgendwelcher Art stattfinden
Laut seinem Biographen Donald Spoto hatte er eine pubertäre Fixierung die in seiner viktorianischen Erziehung begründet lag
Hitchcock äußerte sich zwar oft und gerne über menschliche Körperfunktionen wollte aber den Eindruck erwecken er selbst habe mit solchen Dingen nichts zu tun Bezugnehmend auf seine Körperfülle deutete Hitchcock hingegen mehrfach an dass für ihn Essen eine Art Ersatzbefriedigung sei
So gibt es in einigen Hitchcockfilmen eine symbolische Verbindung von Essen Sex und Tod
Zensur
In den USA galt zwischen <num> und <num> der
Hays Code
auch Production Code genannt eine Sammlung von Richtlinien über die Einhaltung der gängigen Moralvorstellungen und über die Zulässigkeit der Darstellung von Kriminalität Gewalt und Sexualität im Film
So musste Hitchcock zum Beispiel das geplante Ende für Verdacht fallen lassen weil es Anfang der <num>er Jahre nicht möglich war den Selbstmord einer schwangeren Frau zu zeigen
Noch bis kurz vor Schluss der Dreharbeiten hatte er kein passendes Ende für den Film gefunden
In Berüchtigt musste Hitchcock einen Dialog streichen in dem sich ein Vertreter der US-Regierung positiv über die Möglichkeit einer Ehescheidung äußerte Bei Saboteure drehte er politisch heikle Textstellen zur Sicherheit alternativ in entschärften Versionen
Doch in vielen Fällen gelang es ihm die Beschränkungen durch die Zensur kreativ zu umgehen
So war es damals unter anderem nicht erlaubt eine Toilette zu zeigen
Daher verzerrte Hitchcock in Mr
und Mrs Smith
die eindeutigen Geräusche einer Toilette so dass man sie für eine Dampfheizung halten konnte
In Psycho zeigte er eine Toilette in der ein Papierzettel hinuntergespült wurde
Indem er das Bild der Toilette mit einer dramaturgischen Funktion versah - das Verschwinden eines Beweisstücks musste erklärt werden - verhinderte er dass die Szene geschnitten wurde
Niemals wurde eine Toilette zu Zeiten des Hays Code expliziter gezeigt
Da auch die Länge von Küssen im Film damals auf drei Sekunden begrenzt war inszenierte Hitchcock den Kuss zwischen Ingrid Bergman und Cary Grant in Berüchtigt als Folge von einzelnen durch kurze Dialogsätze unterbrochenen Küssen
Hitchcocks größter Sieg gegen die Zensur war die Schlussszene von Der unsichtbare Dritte Cary Grant und Eva Marie Saint befinden sich in einem Schlafwagen
Er zieht sie zu sich nach oben in das obere Bett und sie küssen sich
Es erfolgt ein Umschnitt und man sieht einen Zug in einen Tunnel rasen - eine der explizitesten Andeutungen des Sexualakts in einem US-Film zu Zeiten des Production Code
Arbeitsweise
Einer der wichtigsten Aspekte der Arbeitsweise Alfred Hitchcocks war dass er im Idealfall von der Stoffauswahl bis zum Endschnitt nichts dem Zufall überließ sondern die völlige Kontrolle über die Herstellung des Films beanspruchte
Wenn Hitchcock existierende Vorlagen benutzte etwa Romane oder Bühnenstücke übernahm er nur einzelne Grundmotive der Handlung und entwickelte daraus zusammen mit dem jeweiligen Drehbuchautor oft eine völlig neue Geschichte
Hochwertige komplexe Literatur sperrte sich gegen diesen Umgang und Hitchcock scheute daher deren Verfilmung - auch aus Respekt vor dem Werk
Hitchcock war meist an der Drehbucherstellung beteiligt wurde aber nach <num> bei keinem seiner Filme offiziell als Autor in Vor- oder Abspann erwähnt Ich will nie einen Titel als Produzent oder Autor
Ich habe das Design des Films geschrieben
Mit anderen Worten ich setze mich mit dem Autor zusammen und entwerfe den ganzen Film vom Anfang bis zum Ende Der Autor Samuel A Taylor Mit ihm zu arbeiten bedeutete auch mit ihm zu schreiben was auf die wenigsten Regisseure zutrifft
Hitchcock behauptete nie selbst ein Schriftsteller zu sein aber in Wahrheit schrieb er doch seine eigenen Drehbücher denn er sah bereits jede Szene deutlich in seinem Kopf vor sich und hatte eine sehr genaue Vorstellung davon wie sie ablaufen sollte
Ich merkte dass ich nur noch die Figuren persönlicher und menschlicher zu gestalten brauchte und sie weiter entwickeln musste Gelegentlich veränderte Hitchcock im Nachhinein noch die Dialoge ganzer Szenen etwa um die Spannungs-Dramaturgie zu verbessern Beispiel Das Rettungsboot oder um autobiographische Bezüge einzubauen Beispiel Ich beichte
Auch wenn ihm geschliffene Dialoge wichtig waren legte Hitchcock sein Hauptaugenmerk stets auf die Ausdruckskraft der Bilder
So wurde im Idealfall jede einzelne Einstellung des Films vor Drehbeginn in Storyboards festgelegt
Seit Beginn seiner Regisseurtätigkeit verfolgte er das Ziel jegliche Improvisation so weit es geht zu vermeiden
Gegenüber Truffaut erklärte er Ich habe Angst davor gehabt im Atelier zu improvisieren weil selbst wenn man im Augenblick Ideen hat bestimmt keine Zeit bleibt nachzuprüfen was sie taugen
Andere Regisseure lassen ein ganzes Team warten und setzen sich hin um zu überlegen
Nein das könnte ich nicht
Nach eigenen Aussagen bereitete Hitchcock die Planung eines Projekts mehr Freude als die eigentlichen Dreharbeiten Durch zu viele Einflüsse - Produzenten Technik Schauspieler Zeitdruck - sah er die angestrebte Kontrolle über sein Werk bedroht
Außerdem sah er im Idealfall die kreative Arbeit am Film mit Beginn der Dreharbeiten als abgeschlossen an Ich drehe einen vorgeschnittenen Film
Mit anderen Worten jedes Stück Film ist entworfen um eine Funktion zu erfüllen
Diese Grundsätze waren jedoch eher eine Idealvorstellung Hitchcocks
Tatsächlich wurde es ihm spätestens ab <num> zur Gewohnheit beim Drehen Alternativen auszuprobieren
Doch auch hier bemühte er sich um möglichst exakte Vorausplanung Ein Beispiel hierfür ist die Belagerung des Hauses durch die Vögel in Die Vögel
Gegenüber Truffaut beschrieb Hitchcock wie er die ursprünglich geplante Szene noch unmittelbar am Drehort umschrieb und bis ins kleinste Detail skizzierte so dass sie kurz darauf entsprechend diesen neuen Entwürfen gedreht werden konnte Darüber hinaus wurde Hitchcock im Laufe seiner Karriere immer freier auch kurzfristig vom festgelegten Drehbuch abzuweichen
Entgegen seinen Gewohnheiten ließ er sogar Improvisationen der Schauspieler zu wenn auch nur bei eher unwichtigen Szenen Bill Krohn ging <num> in Hitchcock at Work ausführlich auf Hitchcocks Arbeitsweise ein
Er rekonstruierte auf Basis von Originalunterlagen wie Drehbuchversionen Skripte Storyboards Memos Produktionsnotizen etc und mit Hilfe von Beteiligten die Produktionsgeschichte diverser Filme darunter Hitchcocks berühmteste und widerlegt Hitchcocks Bekenntnis zum vorgeschnittenen Films So kam es bei vielen Filmen vor dass Hitchcock entscheidende Schlüsselszenen in verschiedenen Varianten drehte und meist erst im Schneideraum über die endgültige Form einzelner Szenen entschied
Mitarbeiter
Im Laufe der Jahre entwickelte sich mit verschiedenen Autoren eine besonders kreative Zusammenarbeit
Hervorzuheben sind Eliot Stannard Angus McPhail Charles Bennett Ben Hecht und John Michael Hayes
Obwohl Samuel A Taylor Vertigo und auch Ernest Lehman Der unsichtbare Dritte nur je zwei Drehbücher zu tatsächlich realisierten Filmen schrieben gehörten sie zu den wenigen Mitarbeitern die mit ihm in den letzten Jahren seiner Karriere regelmäßig zusammenarbeiteten und bis kurz vor seinem Tod Kontakt hatten
Doch auch mit namhaften Theater- oder Romanautoren arbeitete Hitchcock mehrfach bei der Drehbucherstellung zusammen reibungslos mit Thornton Wilder und George Tabori konfliktbeladen mit John Steinbeck Raymond Chandler und Leon Uris Der Kult den Hitchcock gern um seine Person betrieb und sein manchmal diktatorischer Stil führte auch zu Konflikten mit befreundeten Autoren
John Michael Hayes der im Streit von Hitchcock schied Ich tat für ihn was jeder andere Autor für ihn tat - ich schrieb
Wenn man aber Hitchcocks Interviews liest kann man den Eindruck bekommen er habe das Drehbuch geschrieben die Charaktere entwickelt die Motivation beigesteuert Wenn Hitchcock mit der Arbeit eines Autors nicht zufrieden war oder wenn er seine Autorität angegriffen fühlte dann ersetzte er Autoren kurzerhand durch andere
Cary Grant und James Stewart wurden innerhalb der jeweils vier Filme die sie für Hitchcock drehten zu Hitchcocks Alter Ego
Grant wurde zu dem was Hitchcock gerne gewesen wäre wie es Hitchcocks Biograph Donald Spoto formulierte während Stewart vieles wäre von dem Hitchcock dachte er sei es selbst Mit einigen seiner Schauspieler verband Hitchcock zudem eine langjährige persönliche Freundschaft allen voran mit Grace Kelly Darüber hinaus sind die als neurotisch zu bezeichnenden Beziehungen zu seinen blonden Hauptdarstellerinnen - insbesondere mit Tippi Hedren - bekannt
Am Anfang von Hitchcocks Karriere galt Film in England als Unterhaltung für die Unterschicht
Aus dieser Zeit stammt Hitchcocks oft zitierter Ausspruch Alle Schauspieler sind Vieh der sich auf diejenigen Theaterschauspieler bezog die nur mit Widerwillen und des Geldes wegen nebenher als Filmschauspieler arbeiteten
Die Aussage verselbständigte sich später und wurde oft als genereller Ausdruck der Geringschätzung Hitchcocks Schauspielern gegenüber angesehen
Tatsächlich hatte er auch später oft Probleme mit Schauspielern die eigene Vorstellungen durchsetzen wollten anstatt sich in die vorgefertigte Planung des Regisseurs einzufügen
Anhänger des Method Actings wie Montgomery Clift und Paul Newman waren Hitchcock daher genauso lästig wie Exzentriker oder Egomanen
Große Achtung hatte Hitchcock hingegen vor Schauspielern die sein Filmverständnis teilten oder sich zumindest seiner Arbeitsweise anpassten und gewährte etwa Joseph Cotten und Marlene Dietrich große künstlerische Freiheiten Oft waren es jedoch die Produzenten die über die Besetzung der Hauptrollen entschieden
Umso mehr nutzte Hitchcock seine größere Freiheit bei den zu besetzenden Nebenrollen wobei er gerne auf Theaterschauspieler zurückgriff die er noch aus seiner Zeit in London in bester Erinnerung hatte zum Beispiel Leo G Carroll in insgesamt sechs Filmen oder Cedric Hardwicke in Verdacht und Cocktail für eine Leiche
Die bekannte Kostümbildnerin Edith Head mit der er ab Das Fenster zum Hof bei fast allen Filmen zusammenarbeitete meinte Loyalität war Hitchcock besonders wichtig
Er war Mitarbeitern gegenüber so loyal wie er es von ihnen erwartete
Bei fünf Filmen war Robert F Boyle für das Production Design verantwortlich er gehörte bis zu Hitchcocks Tod zu dessen engsten Mitarbeitern
Außerdem griff er im Laufe seiner Karriere gern auf Albert Whitlock als Szenenbildner zurück
Äußerst zufrieden war Hitchcock dem die Ausdruckskraft der Bilder stets wichtig war auch mit dem Art Director Henry Bumstead
Der Titeldesigner Saul Bass entwarf nicht nur einige Filmtitel für die Vorspanne sowie Plakate sondern war bereits bei den Arbeiten an vielen Storyboards maßgeblich beteiligt
Wichtigster Kameramann in seinen frühen Jahren bei den British International Pictures war John J Cox
Über Hitchcock sagte Kameramann Robert Burks der mit Ausnahme von Psycho an allen Filmen zwischen <num> und <num> beteiligt war Man hatte nie Ärger mit ihm solange man etwas von seiner Arbeit verstand und sie ausführte
Hitchcock bestand auf Perfektion Mit Leonard J South ehemaliger Assistent Burks arbeitete Hitchcock über einen Zeitraum von insgesamt <num> Jahren zusammen
Von den Komponisten der Filmmusiken ist Louis Levy hervorzuheben der die Soundtracks für die frühen englischen Filme von Der Mann der zuviel wußte bis Eine Dame verschwindet beisteuerte
Als der Hitchcock-Komponist schlechthin gilt Bernard Herrmann der ab Immer Ärger mit Harry bis einschließlich Marnie <num> alle Filmmusiken für Hitchcock komponierte
Der Filmeditor George Tomasini war bis zu seinem Tod <num> ein Jahrzehnt lang enger Mitarbeiter Hitchcocks
Zu Beginn seiner Karriere wirkte seine Frau Alma als Editorin bei seinen Filmen mit sie blieb bis zuletzt eine der einflussreichsten Mitarbeiterinnen
Selbstvermarktung
Schon zu Beginn seiner Karriere war Hitchcock die Bedeutung der Vermarktung der eigenen Person bewusst Viele seiner späteren Tätigkeiten sind Teil einer Strategie sich und seinen Namen als Marke zu etablieren
Bereits <num> führte Hitchcock ein stilisiertes Selbstporträt als Logo das bis heute bekannt ist Anfang der <num>er Jahre als er mit dem Erfolg seiner Filme in England populär wurde gründete er mit der Hitchcock Baker Productions Ltd
eine Gesellschaft die bis zu seiner Übersiedlung nach Amerika ausschließlich dafür zuständig war für ihn und mit seiner Person Öffentlichkeitsarbeit zu betreiben
Anschließend wurden diese Aufgaben von der Künstleragentur Selznick-Joyce danach von der Music Corporation of America MCA wahrgenommen wobei der Präsident der MCA Lew Wasserman zu seinem persönlichen Agenten wurde
<num> wurde unter Herman Citron eine neue Gesellschaft gegründet die Hitchcocks Interessen vertrat und seinen Namen vermarktete Diese Selbstvermarktung diente auch dazu eine Machtposition im Produktionsprozess seiner Filme zu erlangen und war somit Teil seines Kampfes um künstlerische Unabhängigkeit
Cameo-Auftritte
Aus Mangel an Statisten in seinen ersten britischen Filmen sah man Hitchcock immer wieder im Hintergrund auftauchen
Daraus entwickelte er eines seiner bekanntesten Markenzeichen Hitchcocks obligatorischer Cameo-Auftritt
Da das Publikum mit der Zeit immer weniger auf die Handlung achtete als vielmehr auf Hitchcock lauerte legte er in späteren Filmen diesen Running Gag möglichst weit an den Filmanfang
In drei Filmen hatte Hitchcock keinen eigentlichen Cameo-Auftritt
In zwei von diesen Filmen trat er auf Fotos in Erscheinung
Das Rettungsboot
spielt ausschließlich in einem kleinen Rettungsboot auf dem Meer
Er ist daher in einer zufällig im Boot liegenden Zeitung in einer Werbeanzeige für eine Diät auf einem Vorher-Nachher-Foto zu sehen Auch in
Bei Anruf Mord
war kein Auftritt möglich
Stattdessen taucht Hitchcock auf einem an der Wand hängenden Foto einer Wiedersehensfeier von College-Absolventen auf
In
Der falsche Mann
schließlich tritt er am Anfang des Films persönlich auf und spricht den Prolog
Dies ist gleichzeitig seine einzige Sprechrolle in einem seiner Kinofilme
Alle bekannten Hitchcock-Cameos chronologisch
ilmAuftrittRolleFilmAuftrittRolleDer MieterErst an einem Schreibtisch in einer Redaktion dann eilt er eine Mütze auf dem Kopf auf den Hauptdarsteller Ivor Novello zu als dieser mit Handschellen an einem Gitter hängt nach <num> bzw <num> minEasy VirtueMit einem Gehstock hinter einem Tennisplatz nach <num> minErpressungLiest in der U-Bahn eine Zeitung und wird dabei von einem Jungen gestört der ihm den Hut über die Ohren zieht nach <num> minMord - Sir John greift ein
Geht im Gespräch mit einer Frau an dem Haus vorbei in dem der Mord stattfand nach <num> minDer Mann der zuviel wußte von <num>Überquert die Straße in einem Regenmantel nach <num> minDie <num> StufenGeht über den Gehsteig und wirft eine Kaugummipackung weg während Robert Donat und Lucie Mannheim fluchtartig das Theater verlassen nach <num> minSabotageGeht an einem Kino vorbei nach <num> minJung und unschuldigVor dem Gerichtsgebäude mit einer Kamera in der Hand nach <num> minEine Dame verschwindetIn der Londoner Victoria Station geht er mit dunklem Mantel und einer Zigarette hastig auf den Bahnsteig nach <num> minRebeccaGeht hinter George Sanders vorbei als dieser neben einer Telefonzelle mit einem Polizisten diskutiert nach <num> minDer AuslandskorrespondentMit Mantel Hut und Tageszeitung kurz nachdem Joel McCrea sein Hotel verlassen hat nach <num> minVerdachtAn einem Briefkasten nach <num> minMr und Mrs SmithAuf der Straße geht er an Robert Montgomery vorbei nach <num> minSaboteureSteht links vor dem Schaufenster eines Drugstore als das Auto des Saboteurs dort anhält nach <num> minIm Schatten des ZweifelsHat beim Kartenspiel im Zug nach Santa Rosa ein Full House nach <num> minIch kämpfe um dichKommt aus dem Fahrstuhl im Hotel Empire mit einem Geigenkasten und einer Zigarette nach <num> minBerüchtigtAuf der Party in Rains Wohnung trinkt Champagner in einem Zug leer und verschwindet dann nach <num> minDer Fall ParadinKommt an der Cumberland Station aus dem Zug mit einem Cellokasten in der Hand nach <num> minCocktail für eine LeicheGeht unmittelbar nach dem Vorspann zusammen mit einer Frau auf dem Bürgersteig
Sein Markenzeichen ist kurz unter der Neonreklame zu sehen nach <num> minSklavin des HerzensEr ist auf dem Empfang des Gouverneurs mit blauem Mantel und braunem Hut zu sehen außerdem später auf der Treppe im Regierungspalast nach <num> bzw <num> minDie rote LolaDreht sich nach Jane Wyman um die sich gerade als Marlene Dietrichs Dienstmädchen verkleidet hat nach <num> minDer Fremde im ZugSteigt mit einem Kontrabass in einen Zug als Farley Granger den Zug in Metcalf verlässt
nach <num> min Als Guy und seine Freundin in einem Museum überraschenderweise auf Bruno treffen läuft im Hintergrund Hitchcock mit einem Buch durch den Saal nach <num> min
Ich beichteGeht am oberen Rand an einer langen Treppe vorbei nach <num> minDas Fenster zum HofZieht im Apartment des Musikers eine Uhr auf nach <num> minImmer Ärger mit HarryBei der Ausstellung von John Forsythe in jener Szene in der der spätere Bilder-Käufer eingeführt wird überquert er hinter einer parkenden Limousine die Straße nach <num> minÜber den Dächern von NizzaEr sitzt neben John Robie Cary Grant im Bus nach <num> minDer Mann der zuviel wußte von <num>Mit dem Rücken zur Kamera auf dem Markt in Marrakesch bei dem Akrobaten kurz vor dem Mord nach <num> minVertigo - Aus dem Reich der TotenIn der Nähe des Büros von Gavin Elster der die Beschattung seiner Frau in Auftrag gibt überquert er in einem grauen Anzug mit einem Flügelhornkoffer eine Straße und geht in eine Werft nach <num> minDer unsichtbare DritteLäuft auf einen Bus zu dessen Tür sich vor seiner Nase schließt nach <num> minPsychoEr steht vom Inneren von Marions Büro aus sichtbar auf der Straße und trägt einen Cowboyhut nach <num> minDie VögelVerlässt die Tierhandlung mit zwei weißen Terriern in dem Moment in dem Tippi Hedren eintritt nach <num> minMarnieVerlässt ein Hotelzimmer und geht durch den Korridor nach <num> minDer zerrissene VorhangSitzt mit einem Baby auf dem Schoß im Hotelfoyer nach <num> minTopasAm La-Guardia-Flughafen in New York steht er aus einem Rollstuhl auf und begrüßt jemanden nach <num> minFrenzyAm Anfang des Films als die Leiche in der Themse gefunden wird steht er in der Menge und ist der einzige der dem Redner nicht applaudiert nach <num> minFamiliengrabIn seinem letzten Film sieht man seine Silhouette hinter der Milchglasscheibe einer Türe mit der Aufschrift Registratur für Geburten und Sterbefälle nach <num> min
Trailer
Während von den Filmgesellschaften üblicherweise für die Vermarktung eigene Abteilungen oder externe Agenturen beauftragt werden trugen bei Hitchcocks Filmen die Werbekampagnen deutlich die Handschrift des Regisseurs
Seine Kino-Trailer waren häufig nicht nur Zusammenschnitte des angekündigten Films Mit steigendem Wiedererkennungswert seiner Person stellte Hitchcock in der Rolle eines Master of Ceremony seine eigenen Filme vor und führte den Zuschauer humorvoll durch die Kulissen
Fernsehen
Auf den Rat seines Agenten Lew Wasserman hin stieg Hitchcock <num> in das Fernsehgeschäft ein
Hitchcock gründete die Fernsehproduktionsfirma Shamley Productions und produzierte bis <num> seine eigene wöchentliche Fernsehserie Am Anfang vieler Folgen begrüßte Hitchcock das Publikum indem er mit ungerührter Miene makabre Ansagetexte sprach
Die Moderationen die ihn zu einer nationalen Berühmtheit machten wurden von dem Bühnenautor James D Allardice verfasst der fortan bis zu seinem Tod <num> für Hitchcock auch als Redenschreiber arbeitete Als Titelmusik für die Serie Alfred Hitchcock Presents verwendete Hitchcock das Hauptthema von Charles Gounods Marche funèbre dune marionette Trauermarsch einer Marionette das sich im Weiteren zu einer Erkennungsmelodie für Hitchcocks Öffentlichkeitsarbeit entwickelte
Bücher und Zeitschriften
<num> schloss Hitchcock einen Lizenzvertrag mit HSD Publications ab der die Überlassung seines Namens für das Krimi-Magazin Alfred Hitchcocks Mystery Magazine zum Inhalt hatte
Die Zeitschrift enthält Mystery- und Kriminalgeschichten Buchrezensionen und Rätsel und erscheint noch heute
Einführungen und Vorworte die mit seinem Namen unterschrieben waren wurden stets von Ghostwritern verfasst
Von <num> bis <num> erschien in den USA die Jugend-Krimi-Reihe The Three Investigators auf Deutsch seit <num>
Die drei
Der Journalist und Autor Robert Arthur kannte Alfred Hitchcock persönlich und bat ihn seinen Namen zur Vermarktung dieser geplanten Buchreihe verwenden zu dürfen
Schließlich baute er die Figur Alfred Hitchcock in die Handlung ein
Anders als in Europa hielt sich der Erfolg der Bücher in den USA in Grenzen
In Deutschland wo die Bücher besonders populär waren entstand die gleichnamige Hörspielreihe
Durch diese bis heute erfolgreichste Hörspielproduktion der Welt wurde der Name Hitchcock auch bei vielen bekannt die mit seinem filmischen Schaffen nicht vertraut waren
Wirkung
Viele Elemente aus seinem Werk sind inzwischen in das Standardrepertoire des Kinos eingegangen ohne dass sie noch bewusst oder direkt mit Hitchcock in Verbindung gebracht werden insbesondere der Einsatz von Suspense als spannungserzeugendem Mittel oder die Verwendung von MacGuffins als handlungsvorantreibendes Element
Darüber hinaus gibt es seit den <num>er Jahren unzählige Beispiele für Thriller oder Dramen teils von sehr namhaften Regisseuren in denen typische Motive Hitchcocks oder seine Stilelemente bewusst kopiert oder variiert werden
Manche dieser Filme sind als Hommage des jeweiligen Regisseurs an Hitchcock zu verstehen in anderen Fällen wurde Hitchcocks Stil übernommen da er sich als erfolgreich und wirksam erwiesen hat
USA
Insbesondere Hitchcocks Erfolgsfilme aus den <num>er bis Anfang der <num>er Jahre inspirierten in den Folgejahren Hollywood-Produktionen die inhaltlich oder stilistisch oft mit Hitchcock in Verbindung gebracht werden
Zu den vielen Hollywood-Regisseuren die Alfred Hitchcock mehr oder weniger direkt beeinflusste zählt Brian De Palma der mit vielen Verweisen und Zitaten auf Hitchcocks Werk arbeitet
Überdies übernahm er in einigen Filmen Grundstrukturen aus dessen Filmen
So entwickelt er in
Dressed to Kill
<num> das Grundmotiv aus
Psycho
weiter und zitiert aus weiteren Hitchcock-Filmen
<num> lehnte sich
Schwarzer Engel
stark an
Vertigo
an
<num> spielt de Palma in
Der Tod kommt zweimal
mit eindeutigen Bezügen auf
Das Fenster zum Hof
und Vertigo
Auch wenn Steven Spielberg selten direkt stilistische Motive kopiert oder adaptiert und nur wenige seiner Filme thematische Parallelen aufzeigen erinnert
Der weiße Hai
<num> in Spannungsaufbau und Dramaturgie an
Die Vögel
und ist die Filmreihe <num>-<num> stark von
Der unsichtbare Dritte
<num> beeinflusst
Auch ein Film wie
Schindlers Liste
<num> wäre in dieser Form ohne den Einfluss Hitchcocks nicht möglich gewesen
Der von Hitchcocks Kameramann Irmin Roberts entwickelte Vertigo-Effekt wird bisweilen auch als Jaws Effect bezeichnet da Spielberg diese relativ schwierig umzusetzende Kameraeinstellung im Weißen Hai Originaltitel Jaws als einer der ersten prominenten Regisseure <num> Jahre nach Vertigo einsetzte
Inzwischen gehört dieser emotional sehr wirkungsvolle Kameratrick zum Standardrepertoire des Hollywood-Kinos
Weitere amerikanische Regisseure die erkennbar von Hitchcock beeinflusst wurden oder sich auf dessen Werk berufen sind John Carpenter David Fincher David Mamet Quentin Tarantino
Martin Scorsese David Lynch und M Night Shyamalan
Frankreich
Bereits seit Mitte der <num>er Jahre war Hitchcock insbesondere in Frankreich bei den Vertretern der Nouvelle Vague hoch angesehen
<num> veröffentlichten die damaligen Filmkritiker und späteren Regisseure Éric Rohmer und Claude Chabrol das erste Buch über ihn
<num> erschien ein Sonderheft der Cahiers du cinéma das maßgeblich zu Hitchcocks Popularität in Frankreich beitrug
Als er im Mai <num> zu einem Filmfestival reiste das die Cinémathèque française ihm zu Ehren in Paris abhielt wurde er von Dutzenden jungen Filmemachern frenetisch gefeiert
Die internationale Ausgabe der Herald Tribune schrieb dass Hitchcock in dieser Woche das Idol der französischen Avantgarde geworden sei
Im August <num> gab Hitchcock dem damals dreißigjährigen französischen Filmkritiker und Regisseur François Truffaut ein fünfzigstündiges Interview
Truffaut befragte Hitchcock chronologisch zu dessen bisherigen achtundvierzig Filmen
Das Interview erschien <num> als
Mr
Hitchcock wie haben Sie das gemacht
in Buchform und gilt als Standardwerk der Filmliteratur
Einzelne Filme Truffauts zeigen den Einfluss Hitchcocks deutlich etwa
Die Braut trug schwarz
<num> oder
Das Geheimnis der falschen Braut
<num> die Geschichte eines Mannes der einer Betrügerin und Mörderin verfällt und auch nicht von ihr lassen kann als sie ihn zu töten versucht
Der Film ist stark von verschiedenen inhaltlichen und stilistischen Motiven aus
Vertigo
Marnie
und
Verdacht
beeinflusst
Sein letzter Film
Auf Liebe und Tod
<num> in dem ein unschuldiger Mann eines Mordes beschuldigt wird ist voll von hitchcockschen Motiven und Anspielungen auf dessen Werk
Weitere Filme die Truffaut selbst in der Tradition Hitchcocks sah waren
Die süße Haut
und
Fahrenheit <num>
<num><num> besetzte Hitchcock die bevorzugte Schauspielerin Truffauts Claude Jade für seinen Film
Topas
In vielen Filmen von Claude Chabrol wird eine scheinbar heile bürgerliche Welt angegriffen und durcheinandergebracht
Die hitchcockschen Hauptmotive der Schuldübertragung sowie der doppelten oder der gespaltenen Persönlichkeit tauchen bei Chabrol immer wieder auf
Einige Beispiele sind
Schrei wenn du kannst
<num>
Das Auge des Bösen
<num>
Der Schlachter
<num> und
Masken
<num>
Neben Chabrol und Truffaut haben sich in Frankreich unter anderen auch Henri-Georges Clouzot und René Clément des hitchcockschen Repertoires bedient
Übriges Europa
Außerhalb Frankreichs war in Europa der unmittelbare Einfluss Hitchcocks auf andere Filmemacher deutlich geringer
Einige europäische oder europäischstämmige Regisseure haben jedoch einzelne Filme gedreht denen eine Stilverwandtschaft anzuerkennen ist oder die unmittelbar als Hommage an Hitchcock gedacht sind zum Beispiel
Ministerium der Angst
von Fritz Lang <num>
Der dritte Mann
von Carol Reed <num>
Zeugin der Anklage
von Billy Wilder <num>
Frantic
von Roman Polański <num> und
Schatten der Vergangenheit
von Kenneth Branagh <num>
Filmografie
Alle Filme an denen Hitchcock beteiligt war in der Reihenfolge ihrer Produktion
Jahr das Jahr der Uraufführung bei nicht oder erst später aufgeführten Filmen das letzte Produktionsjahr
Beteiligung R
Regie R
Hitchcock drehte als Regisseur nur einzelne Szenen und wird im Abspann nicht genannt R TV
Regiearbeiten für das Fernsehen B
Buch nur bei namentlicher Nennung Hitchcock arbeitete jedoch an fast allen Drehbüchern seiner Filme mit und lieferte in vielen Fällen Szenen oder einzelne Dialoge P
Produktion D
Darsteller Statist TA
Treatment Advisor TD
Titel-Designer RA
Regie-Assistent AD
Art Director
ohne namentliche Nennung
Nr Position in den <num> von Hitchcock selbst inszenierten Spielfilmen
Uraufführung für die Kinofilme nach der
Internet Movie Database
für die Fernsehfilme nach Donald Spoto
<num>-<num>
Stummfilme in Schwarzweiß
<num>-<num>
bis einschließlich Nr <num> Stummfilme ab Nr <num> Tonfilme alle Filme in Schwarzweiß
<num>-<num>
alle Filme in Schwarzweiß
In diese Phase fällt auch Hitchcocks einzige Mitarbeit an einem längeren Dokumentarfilm German Concentration Camps Factual Survey von Mai bis Juli <num> in London
Er hat dies später im Interview als seinen Beitrag zum Krieg bezeichnet
Der Film wurde nicht fertiggestellt
<num>-<num>
Filme Nr <num> <num> <num> und <num> in Schwarzweiß alle anderen in Farbe
Zwischen <num> und <num> trat der Regisseur in insgesamt <num> Folgen der Fernsehserien Alfred Hitchcock Presents <num> Folgen und The Alfred Hitchcock Hour <num> Folgen in der Rolle des Gastgebers auf
<num>-<num>
Film Nr <num> in Schwarzweiß alle anderen in Farbe
<num>-<num>
alle Filme in Farbe
Auszeichnungen
DateiHitchcock walk of famejpg
Hitchcock wurde sechsmal für den Oscar nominiert fünfmal für die Beste Regie einmal für den Besten Film als Produzent
Alle sechs Mal ging er leer aus was ihn zu dem Kommentar veranlasste Immer nur Brautjungfer nie die Braut Dennoch blieb er nicht oscarlos denn <num> gewann er den Irving G Thalberg Memorial Award als Spezialoscar für besonders kreative Filmproduzenten
Zudem wurde Rebecca <num> mit dem Oscar für den besten Film ausgezeichnet den aber nicht Hitchcock sondern der Produzent David O Selznick entgegennehmen durfte
<num> NYFCC Award als
Bester Regisseur
für Eine Dame verschwindet
<num> Oscar-Nominierung für Rebecca Beste Regie
<num> Oscar-Nominierung für Verdacht Bester Film
<num> Oscar-Nominierung für Das Rettungsboot Beste Regie
<num> Oscar-Nominierung für Ich kämpfe um dich Beste Regie
<num> Kinema Junpo Award für Verdacht als Bester Fremdsprachiger Film
<num> Preis beim Filmfestival von Locarno für Die rote Lola
<num> Oscar-Nominierung für Das Fenster zum Hof Beste Regie
<num> Golden Globe für The best TV-Show Alfred Hitchcock Presents
<num> Zweiter Platz beim Laurel Award als Bester Regisseur
<num> Silberne Muschel beim Filmfestival von San Sebastián für Vertigo - Aus dem Reich der Toten
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Silberne Muschel beim Filmfestival von San Sebastián für Der unsichtbare Dritte
<num> Oscar-Nominierung für Psycho Beste Regie
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Zweiter Platz beim Laurel Award als Bester Regisseur
Produzent
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Zweiter Platz beim Laurel Award als Bester Regisseur
Produzent
<num> Milestone Award der Producers Guild of America
<num> Ehrung durch die Association of Cinematography Television and Allied Technicians ACTT
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Zweiter Platz beim Laurel Award als Bester Regisseur
Produzent
<num> Irving G Thalberg Memorial Award als Spezialoscar für besonders kreative Filmproduzenten
<num> Ehrendoktorwürde der University of California
<num> D W Griffith Award der Directors Guild of America
<num> Officier des Arts et des Lettres
<num> National Board of Review Award als Bester Regisseur für Topas
<num> Ehrenmitgliedschaft der britischen Society of Film and Television
<num> Golden Laurel als Bester Regisseur
Produzent
<num> Ernennung zum Ritter der Ehrenlegion bei der Cinémathèque française
<num> BAFTA Award für sein Lebenswerk
Academy Fellowship
<num> Golden Globe für sein Lebenswerk Cecil B DeMille Award
<num> Ehrendoktorwürde der Universität von Columbia
<num> Grand Master Award der Mystery Writers of America
<num> Würdigung durch die Film Society of Lincoln Center in New York
<num> AFI Life Achievement Award des American Film Institute
<num> Knight Commander of the British Empire
<num> Jussi Finnland als Bester ausländischer Filmemacher
<num> Life Career Award postum der
Academy of Science Fiction Fantasy
Horror Films USA
Er wurde mit zwei Sternen auf dem Hollywood Walk of Fame geehrt
Den einen in der Kategorie Film findet man bei der Adresse <num> Hollywood Blvd den anderen in der Kategorie Fernsehen am <num> Hollywood Blvd
Biografische Spielfilme über Hitchcock
The Girl TV Spielfilm <num>
Regie Julian Jarrold Besetzung Toby Jones Alfred Hitchcock Sienna Miller Tippi Hedren Imelda Staunton Alma Reville Hitchcock Conrad Kemp Evan Hunter Penelope Wilton Peggy Robertson
Hitchcock
Spielfilm <num>
Regie Sacha Gervasi Besetzung Anthony Hopkins Alfred Hitchcock Helen Mirren Alma Reville Hitchcock Scarlett Johansson Janet Leigh Danny Huston Whitfield Cook Toni Collette Peggy Robertson Michael Stuhlbarg Lew Wasserman Michael Wincott Ed Gein Jessica Biel Vera Miles James DArcy Anthony Perkins
Dokumentarfilme
Hitchcock - Truffaut Dokumentarfilm USA Frankreich <num> <num> Min Buch Kent Jones und Serge Toubiana Regie Kent Jones Produktion arte France Artline Films Cohen Media Group Erstsendung <num> November <num> bei arte Dossier mit Filmausschnitten vom Festival de Cannes <num>
Literatur
Biografien
Laurent Bouzereau Alfred Hitchcock Knesebeck München <num> ISBN <num>-<num>-<num>-<num>-<num> mit einem Vorwort von Patricia Hitchcock OConnell und bisher unveröffentlichtem Bildmaterial und herausnehmbaren Faksimiles von Storyboards und handschriftlichen Notizen
Charlotte Chandler Its Only a Movie Alfred Hitchcock - A Personal Biography Simon
Schuster New York <num> ISBN <num>-<num>-<num>-<num>
Thomas Koebner Alfred Hitchcock In Ders
Hrsg Filmregisseure
Biographien Werkbeschreibung Filmographien
<num> aktualisierte und erweiterte Auflage
Reclam Stuttgart <num> <num> Aufl <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
Patrick McGilligan Alfred Hitchcock
A Life in Darkness and Light
Wiley Chichester <num> ISBN <num>-<num>-<num>-<num>
Enno Patalas Hitchcock dtv München <num> ISBN <num>-<num>-<num>-<num>
Donald Spoto Alfred Hitchcock - Die dunkle Seite des Genies Ins Deutsche übersetzt von Bodo Fründt
Heyne München <num> ISBN <num>-<num>-<num>-X
John Russel Taylor Die Hitchcock-Biographie Fischer Cinema Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num>
Thilo Wydra Alfred Hitchcock
Leben - Werk - Wirkung
Suhrkamp Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
Werkschauen
Sortiert in der chronologischen Reihenfolge der jeweiligen Originalausgabe
Éric Rohmer Claude Chabrol Hitchcock Ed Universitaires Paris <num>
HP
Manz Alfred Hitchcock - eine Bildchronik Mit Texten von Hitchcock Godard Truffaut u a Sanssouci Zürich <num>
François Truffaut
Mr
Hitchcock wie haben Sie das gemacht
Heyne München <num> ISBN <num>-<num>-<num>-<num> Abfolge von Interviews circa <num> Stunden des französischen Regisseurs mit Hitchcock Originalausgabe Le cinéma selon Hitchcock <num> dt etwa Der Film gemäß Hitchcock
Robert A Harris Michael S Lasky Hrsg Joe Hembus Alfred Hitchcock und seine Filme OT The Films of Alfred Hitchcock
Citadel-Filmbücher bei Goldmann München <num> ISBN <num>-<num>-<num>-<num>
François Truffaut Robert Fischer Hrsg Truffaut Hitchcock Diana Zürich <num> ISBN <num>-<num>-<num>-<num> frz Original <num> erweiterte und gebundene Ausgabe von Mr
Hitchcock wie haben Sie das gemacht
<num>
Bodo Fründt Alfred Hitchcock und seine Filme Heyne Filmbibliothek Band Nr <num> München <num> ISBN <num>-<num>-<num>-<num>
Robert E Kapsis Hitchcock The Making of a Reputation University of Chicago Press Chicago <num> ISBN <num>-<num>-<num>-<num> wissenschaftliche englischsprachige Arbeit die informationsreich den aufgebauten Ruf Hitchcocks beleuchtet und so auch auf Nachahmungen seiner Filme eingeht speziell Brian De Palma
Frank Schnelle Hrsg Alfred Hitchcocks Psycho Verlag Robert Fischer
Uwe Wiedleroither Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Eva Rieger Alfred Hitchcock und die Musik
Eine Untersuchung zum Verhältnis von Film Musik und Geschlecht
Kleine Bielefeld <num> ISBN <num>-<num>-<num>-<num>
Donald Spoto Alfred Hitchcock und seine Filme Wilhelm Heyne München <num> ISBN <num>-<num>-<num>-X
Lars-Olav Beier Georg Seeßlen Hrsg Alfred Hitchcock Bertz
Fischer Berlin <num> ISBN <num>-<num>-<num>-<num>
Bill Krohn Hitchcock at Work Phaidon Wien <num> ISBN <num>-<num>-<num>-<num> detaillierte Studie über Hitchcocks Arbeitsweise in seiner amerikanischen Zeit
Paul Duncan Alfred Hitchcock The Complete Films Deutsch im Taschen-Verlag Köln <num> ISBN <num>-<num>-<num>-X
Nikolai Wojtko Hrsg Alfred Hitchcock - der Filmverführer Kovac Hamburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Gregor J Weber Jeder tötet was er liebt
Liebes- und Todesszenen in den Filmen Alfred Hitchcocks
Schüren Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Adrian Weibel Spannung bei Hitchcock
Zur Funktionsweise des auktorialen Suspense
Königshausen
Neumann Würzburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Henry Keazor Hrsg Hitchcock und die Künste Schüren Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Éric Rohmer und Claude Chabrol Hitchcock Hrsg und aus dem Französischen von Robert Fischer
Alexander Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
Stephen Rebello Hitchcock und die Geschichte von Psycho Wilhelm Heyne München <num> ISBN <num>-<num>-<num>-<num>-<num> Grundlage für das Drehbuch von Hitchcock
Paul Duncan Hrsg Alfred Hitchcock
Sämtliche Filme
Taschen Köln <num> ISBN <num>-<num>-<num>-<num>-<num> Mit zahlreichen Filmfotos Kinoplakaten und Bildern von Dreharbeiten
Weiteres
Antoine de Baecque Serge Toubiana François Truffaut - Biographie Éditions Gallimard Paris <num> dt <num> Egmont vgs Verlagsgesellschaft ISBN <num>-<num>-<num>-<num>
FußnotenEinzelnachweise
Hauptquellen sind die beiden Biografien von Taylor und Spoto sowie die Bücher von Truffaut und Krohn
Weblinks
Hitchcock-Wiki hitchcocktv - umfangreiche englischsprachige Privatseite
Hitchcock EyeGate Sammlung Alfred Hitchcock Homepage - umfangreiche deutschsprachige Privatseite von Hermann Holzner
abgerufen am <num> September <num>die biografischen Daten entstammen in der Regel den Biografien von Spoto und Taylor Laut Spoto dort S <num> war St Ignatius nie ein Internat wie dies andere Quellen oft behaupten zu den diesbezüglich provozierten Spuren im Werk des Regisseurs vgl Henry Keazor Hrsg Hitchcock und die Künste Marburg Schüren <num> hier insbesondere die Einleitung S <num>-<num> Vgl u a Taylor S <num>f httpswwwyoutubecomwatchvIceUa<num>c-<num>zY httpswwwyoutubecomwatchv-HXLIx<num>KhKg Er selbst bezeichnete später Der Mieter als seinen eigentlich ersten Film Vgl Duncan S <num>Vgl Spoto S <num>ff Vgl Spoto S <num> Vgl u a Duncan S <num>Verschiedene Sprachversionen waren bei den frühen Tonfilmen üblich Siehe Duncan S <num> Vgl Taylor S <num> Vgl Spoto S <num> Vgl Spoto S <num> Vgl Spoto S <num> Vgl Truffaut <num> S <num>ff Vgl Spoto S <num>-<num> Vgl Spoto S <num>ff Vgl Taylor S <num> Vgl Spoto S <num>Donald Spoto schreibt Burks sei noch im selben Jahr bei einem Hausbrand ums Leben gekommen Dies ist falsch Er starb erst <num> Vgl Taylor S <num>f Vgl Spoto S <num>f Hitchcock im September <num> siehe Spoto S <num> Siehe Spoto S <num> Vgl Spoto S <num>ff Siehe Donald Spoto The Art of Alfred Hitchcock Fifty Years of Motion Pictures New York London etc Doubleday <num> S <num>-<num> Vgl Truffaut <num> S <num> Vgl Truffaut <num> S <num> In Psycho indem die Mutter über ihren Tod hinaus von ihrem Sohn Besitz ergreift und Nebenbuhlerinnen ermordet In Die Vögel ist die Mutter nicht in der Lage ihren erwachsenen Sohn loszulassen Hitchcock selbst sagte hierzu Sie hat ihren Sohn ihren Ehemann ersetzen lassen Siehe Spoto S <num> Bezeichnenderweise beginnt Hitchcocks erster Film Irrgarten der Leidenschaft mit einer Treppenszene und sein letzter Film Familiengrab endet mit einer solchen Hitchcock erklärte die Verwendung dieser Symbolik so Psychologisch betrachtet haben die Handschellen natürlich eine tiefere Bedeutung Irgendwie hat es schon etwas mit Fetischismus zu tun und hat auch sexuelle Untertöne Als ich einmal in Paris das Kriminalmuseum besuchte bemerkte ich dass sexuelle Abartigkeiten sehr häufig im Zusammenhang mit Fesselung standen Siehe Spoto S <num> Vgl Spoto S <num>f In Verdacht ist Grant ein Hochstapler und Verführer der sich über beide Ohren verschuldet seine Frau belügt und von ihr verdächtigt wird sie ermorden zu wollen In Berüchtigt erwartet er als Geheimdienstmitarbeiter von der Frau mit der er eine Liebesbeziehung hat dass diese aus staatsbürgerlichem Pflichtbewusstsein mit einem anderen Mann schläft Als sie dies tut und den anderen sogar heiratet übersieht er in seiner Eifersucht lange dass sie dabei ist vergiftet zu werden Die Blondine erscheint vor allem in Hitchcocks berühmtesten und erfolgreichsten Filmen der <num>er- und <num>er-Jahre verkörpert durch Grace Kelly Eva Marie Saint Kim Novak Janet Leigh und Tippi Hedren In früheren Filmen standen Anny Ondra Madeleine Carroll Joan Fontaine und vor allem Ingrid Bergman für diesen Typus und selbst in seinen ganz frühen Filmen traten blonde Hauptdarstellerinnen auf Corey K Creekmur Alexander Doty Out in Culture Gay Lesbian and Queer Essays on Popular Culture Continuum International Publishing Group <num> S <num> Shohini Chaudhuri Feminist Film Theorists Laura Mulvey Kaja Silverman Teresa de Lauretis Barbara Creed Taylor
Francis <num> S <num> Siehe Truffaut <num> S <num> Siehe Truffaut <num> S <num> Vgl Spoto S <num> Siehe Spoto S <num> Gegenüber Truffaut bezeichnete er dies als idiotisch und als verzeihlichen Versuch als weitaus größeren Fehler nämlich als unverzeihlichen Irrtum sah er jedoch an dass er ein Jahr später in Sklavin des Herzens die gleiche Methode wiederholte und bis zu sieben Minuten lange ungeschnittene Einstellungen drehte für die es keine Notwendigkeit gab Vgl Truffaut <num> S <num> <num> Siehe Spoto S <num> Vgl Spoto S <num> Siehe Spoto S <num> Vgl Truffaut <num> S <num> Siehe Spoto S <num> Vgl Spoto S <num> <num> Es gibt über ein Dutzend Filme mit solchen Einstellungen Sehr eindrucksvoll ist der stumme Schrei von Lydia Brenner Jessica Tandy in
Vgl auch Duncan S <num>Vgl Foster Hirsch
The Dark Side of the Screen Film Noir
Da Capo Press Boston <num> unpaginiert Auszug Siehe Truffaut <num> S <num> Donald Spoto Alfred Hitchcock - Die dunkle Seite des Genies S <num> Vgl u a Spoto S <num> <num>f Vgl Spoto S <num>ff In dem Film No Bail for the Judge den er <num> mit Audrey Hepburn inszenieren wollte in einem Film namens Frenzy über einen psychopathischen Frauenmörder den er <num> drehen wollte und der nichts mit dem gleichnamigen Film von <num> zu tun hat und in seinem letzten Projekt The Short Night das er ab <num> verfolgte und nicht mehr zu Ende bringen konnte Vgl Spoto S <num> Vgl Spoto S <num>ff Vgl Spoto S <num>ff Vgl Spoto S <num> <num> Vgl Spoto S <num> <num> Vgl Krohn S <num>f Vgl Krohn S <num>ff Vgl Krohn S <num>ff Hitchcock selbst nannte es die impertinenteste Schlusseinstellung die ich je gemacht habe s Truffaut <num> S <num> Siehe Spoto S <num> Taylor über die Zusammenarbeit bei Vertigo siehe Spoto S <num> Siehe Truffaut <num> S <num>siehe Spoto <num> S <num>f Vgl Truffaut <num> S <num>ff Ein Beispiel ist der Dialog in der dreiminütigen Kussszene zwischen Cary Grant und Ingrid Bergman in Berüchtigt der die einzelnen Küsse verbindet Vgl Spoto S <num>f <num> John Michael Hayes über die Zusammenarbeit an Das Fenster zum Hof in Spoto S <num> So geschah dies mit Evan Hunter Ernest Lehman oder Anthony Shaffer - drei Autoren mit denen Hitchcock zuvor erfolgreich zusammengearbeitet hatte Vgl Spoto S <num> <num>f und <num> Siehe Spoto S <num>f Gute Kontakte pflegte er auch mit Tallulah Bankhead Ingrid Bergman Anny Ondra oder Carole Lombard So durfte Joseph Cotten seine Garderobe für Im Schatten des Zweifels selbst aussuchen während Marlene Dietrich in Die rote Lola sogar dem Kameramann und dem Beleuchter Anweisungen geben durfte wie sie am besten auszuleuchten und aufzunehmen sei Vgl Spoto S <num> Vgl u a Truffaut <num> S <num>f <num> <num> <num> Siehe Duncan S <num> Siehe Spoto S <num>Klangbeispiele und umfangreiche Informationen zur Zusammenarbeit von Hitchcock mit Herrmann finden sich im Artikel
Hitchcocks Hofkomponist Bernard Herrmann
moviepilotdeSiehe
Vgl Spoto S <num> <num> <num>Vgl u a HarrisLasky Seite <num>Laut Hitchcocks Aussage in einem späteren Interview sei die erste Idee gewesen ihn als Leiche am Rettungsboot vorbei treiben zu lassen doch dies wurde verworfen da Hitchcock nach eigenen Angaben zu große Angst vor dem Ertrinken hatte Hitchcock erhielt <num> Dollar pro Folge und jeweils nach der ersten Ausstrahlung alle Rechte an der Weiterverwertung - ein zu damaliger Zeit beispielloser Vertrag Vgl u a Spoto S <num>ff Vgl Spoto S <num>ff <num> Taylor S <num>ff Siehe hitchcocktv Vgl Duncan S <num> Hitchcock genoss diese Anerkennung obwohl er das Ausmaß der Begeisterung nicht ganz verstand - er sah sich selbst nie als Autorenfilmer Joseph Stefano mit dem Hitchcock zu dieser Zeit zusammenarbeitete sagte später Hitchcock liebte die Aufmerksamkeit und das Getue und den Ruhm und wenn er nicht verstand weshalb man so eine Aufregung machte dann fühlte er sich doch nicht verpflichtet es zu ergründen Es war gut für das Geschäft und es war gut für sein Ego Siehe Spoto S <num>vgl de BaecqueToubiana S <num>Weitere Beispiele
Die Wendeltreppe
von Robert Siodmak <num>
Es geschah am hellichten Tag
von Ladislao Vajda <num> und
Do You Like Hitchcock
von Dario Argento <num> Vgl Spoto S <num>
Die Auteur-Theorie von frz Auteur
Autor ist eine Filmtheorie und die theoretische Grundlage für den Autorenfilm - insbesondere den französischen - in den <num>er Jahren der sich vom Produzenten-Kino abgrenzte
Auch heute noch wird die Definition des Auteur-Begriffs ständig weiterentwickelt
Im Zentrum des Films steht für die Auteur-Theorie der Regisseur oder Filmemacher als geistiger Urheber und zentraler Gestalter des Kunstwerks
Geschichte der Auteur-Theorie
Ende der <num>er Jahre wurde eine erste Auteur-Theorie von dem französischen Filmkritiker Alexandre Astruc formuliert indem er die Frage nach dem geistigen Besitz eines Films aufwarf
Im traditionellen Schaffensprozess lassen sich die Anteile von Drehbuchautor Kameramann und Filmregisseur am Gesamtwerk nur schwer zuordnen
Durch die Zuteilung der Teilaufgaben als Honorartätigkeit durch die Filmgesellschaften leide die Kreativität so die These
Im Umkehrschluss fordert diese Theorie die Zusammenführung der Tätigkeiten zu einer kreativen Einheit
Er formulierte seinen Entwurf in dem Aufsatz La caméra-stylo Die Kamera sollte wie ein Stift verwendet werden
Er war sich sicher dass bedeutende Schriften in Zukunft nicht mehr als Text sondern mit der Kamera geschrieben würden
Doch durchgesetzt haben sich solche und ähnliche Ideen der Auteur-Theorie erst in den <num>er Jahren
Deren gängiger Begriff als Wegbereiter für die heutige Auteur-Theorie lautete zunächst politique des auteurs Autoren-Politik was erst im Laufe der Zeit zur Theorie umgeformt wurde
Das Wort politique bzw Politik stand hier also eher für Parteilichkeit welche für filmwissenschaftliche Diskussionen eher hinderlich ist siehe unten
Die politique des auteurs wurde zu dieser Zeit von einer Gruppe von jungen Filmkritikern um André Bazin entwickelt die für die Filmzeitschrift
Cahiers du cinéma
schrieben
Eine wesentliche Rolle spielte dabei François Truffaut Im Januar <num> veröffentlichte er seinen Aufsehen erregenden Aufsatz
Eine gewisse Tendenz im französischen Film
Une certaine tendance du cinéma français in dem er sich mit scharfer Polemik gegen den etablierten französischen Qualitätsfilm wandte
Bei diesem trat der Regisseur gegenüber dem Drehbuchautor und dem Autor der literarischen Vorlage oft in den Hintergrund
Truffaut plädierte dagegen für einen Film bei dem Form und Inhalt vollständig vom Regisseur selbst als dem eigentlichen auteur des Films bestimmt werden
Er fand das bei traditionell als Autoren ihrer Filme betrachteten europäischen Regisseuren wie Luis Buñuel Jean Renoir und Roberto Rossellini außerdem aber auch und vor allem bei Regisseuren wie Alfred Hitchcock Howard Hawks Fritz Lang und Vincente Minnelli die zum großen Teil als Vertragsregisseure im Studiosystem Hollywoods arbeiteten deren Filme aber trotzdem einen persönlichen Stil aufweisen
Das Konzept des Regisseurs als auteur seiner Filme wurde für die Filmkritik der Cahiers du cinéma bestimmend und damit für die Regisseure der Nouvelle Vague die daraus hervorgingen neben Truffaut etwa Jean-Luc Godard Jacques Rivette oder Claude Chabrol - Filmemacher die sich zur Umsetzung ihrer künstlerischen Ziele einer jeweils ganz eigenen filmischen Form bedienten
Roland Barthes hingegen misst in seinem Essay La mort de lauteur <num>
Der Tod des Autors
dem Autor für die Literatur eine weitaus geringere Bedeutung bei als es bisher der Fall war
Der Auteur-Dieu Autoren-Gott wird von Barthes durch den écrivain den Schriftsteller ersetzt und folgt damit einer Kritik die Julia Kristeva bereits <num> in ihrem Aufsatz
Bakhtine le mot le dialogue et le roman Bachtin das Wort der Dialog und der Roman <num> aufbrachte
Für den europäischen Film blieb die Auteur-Theorie aber noch bis in die <num>er prägend
Danach setzte auch hier eine Abkehr von der verhängnisvollen Macht der Regisseure Günter Rohrbach ein
Wirtschaftlicher Druck zwang zur Rückkehr zu einer arbeitsteiligen Produktionsweise wie sie für den Produzenten-Film charakteristisch ist
Damit einher ging notwendigerweise auch wieder die Einigung aller Beteiligten auf einen kleinsten gemeinsamen Nenner und somit auch häufig eine gewisse Banalisierung der Filminhalte die umso stärker zu Tage tritt je weniger der Produzent als Projektverantwortlicher in den eigentlichen schöpferischen Prozess eingebunden ist
In der Filmwissenschaft wurden auch immer neue Autorschaften von Teammitgliedern entdeckt
In der Realität ist Film Teamarbeit und es ist dem Film nicht anzusehen ob zum Beispiel die Idee für eine Einstellung nun vom Regisseur oder vom Kameramann stammt
Im Dogma-Film ist der Kameramann nicht weisungsgebunden
Die Polnische Schule bindet den Kameramann bereits in den Prozess des Drehbuchschreibens ein
Unerfahrene Regisseure sind meist sehr auf die Kreativität des Kameramanns oder der Kamerafrau und anderer Teammitglieder angewiesen
Durch das Aufkommen digitaler Aufnahmetechniken wie Digital Video seit Ende der <num>er Jahre sehen viele Filmemacher wie etwa Wim Wenders wieder günstigere Bedingungen für individuelle subjektive Produktionen gegeben
Kritik und Diskussion
Die von François Truffaut und Jean-Luc Godard proklamierte politique des auteurs Autorenpolitik der fünfziger Jahre war ursprünglich ein Versuch bestimmte Regisseure wie Alfred Hitchcock als Künstler anzuerkennen die ihre völlig eigene Bildsprache entwickelten oder wie Truffaut selber sämtliche Aspekte ihrer Filme selbst bestimmten
Ein Autorenfilmer ist demnach ein Regisseur der einen Film - möglichst ohne Kompromisse - so gestaltet wie er ihn selbst haben möchte
Die politique des auteurs geriet schnell in die Kritik
Kritiker wie Andrew Sarris und Peter Wollen wiesen auf ein empirisches Problem hin Niemand kann beweisen wie viel Einfluss der Regisseur wirklich auf seine Filme hatte bzw welchen Einfluss Form und Inhalt wirklich auf das haben was wir als Autorschaft wahrnehmen
Als Beispiel hierfür gilt der Vorspann von
Vertigo - Aus dem Reich der Toten
<num> den Alfred Hitchcock nicht selbst angefertigt hat oder die Tatsache dass viele seiner Filme auf einer Buchvorlage fremder Autoren basieren und selbst die Drehbücher selten von ihm selbst stammten
Gerade Hitchcock aber ist eine zentrale Figur in der politique des auteurs
Wie der Name politique des auteurs sagt handelte es sich um eine Politik einen gezielten polemischen Eingriff
Der Village-Voice-Kritiker Andrew Sarris übersetzte politique des auteurs jedoch <num> mit auteur theory wobei unklar blieb in welchem Sinne es sich hier tatsächlich um eine
Theorie
handelt
Sarris popularisierte diese Theorie im englischen Sprachraum und benutzte sie vor allem um die absolute Überlegenheit des Hollywood-Kinos darzulegen war er doch davon überzeugt es sei the only cinema in the world worth exploring in depth beneath the frosting of a few great directors at the top Nun war die Frage Wo ist die Grenze
Wen oder vielmehr was nehmen wir als Autor wahr
Soziologisch gesehen war die Autorentheorie eine Distinktionsstrategie junger Kritiker die auf sich aufmerksam machen wollten
Godard hat dies später offen zugegeben Wir sagten von Preminger und den anderen Regisseuren die für Studios arbeiteten wie man heute fürs Fernsehen arbeitet Sie sind Lohnempfänger aber gleichzeitig mehr als das denn sie haben Talent einige sogar Genie
aber das war total falsch
Wir haben das gesagt weil wir es glaubten aber in Wirklichkeit steckt dahinter dass wir auf uns aufmerksam machen wollten weil niemand auf uns hörte
Die Türen waren zu
Deshalb mussten wir sagen Hitchcock ist ein größeres Genie als Chateaubriand
In den siebziger Jahren folgte dann die stärkste Kritik an der politique des auteurs Roland Barthes proklamierte bereits <num> vor einem poststrukturalistischen Hintergrund den Tod des Autors Der Autor wurde nun aufgrund des empirischen Dilemmas der Beweisbarkeit von Autorschaften als Image-Figur erkannt die sich aus ihrer Umwelt formt und in die Werke einschreibt
Auch von feministischer Seite wurde die politique des auteurs scharf angegriffen diene sie doch dazu den kollektiven Charakter des Filmemachens zu verdecken und in der Tradition patriarchaler Heldenverehrung Männer zu Superstars zu stilisieren
Claire Johnston verteidigte den Ansatz insofern als dieser einer zu monolithischen Sicht des Hollywood-Kinos entgegenwirke
In den neunziger Jahren schließlich ging die Tendenz zu der Annahme dass Autorschaften zum Großteil z T kommerziell konstruiert sind
Timothy Corrigan nennt dies den commercial auteur Es wird damit gerechnet dass das Publikum den Film eines als Autor bekannten Regisseurs als z B Der neue Woody Allen wahrnimmt ohne wirklich zu wissen wie viel Einfluss Woody Allen tatsächlich auf den Film hatte
Dana Polan verfolgte einen weiteren interessanten Ansatz Er sieht den auteurist als Hauptverantwortlichen für konstruierte Autorenbilder
Das sind Kritiker die den Autor als höchste Instanz suchen und damit - wie François Truffaut - auf einen Filmemacher als Künstler hinweisen wollen und nebenbei ihre eigene Erkenntniskraft zelebrieren
Der Begriff dafür lautet Auteur Desire Dieser Ansatz zeigt noch einmal den größten Vorwurf gegenüber der politique des auteurs auf
Doch trotzdem ist die Nennung eines Regisseurs parallel zu - beispielsweise - einem Buchautor als Schöpfergeist auch unter reflektierenden Filmkritikern und -wissenschaftlern weiterhin außerordentlich beliebt
Steckt also doch mehr dahinter
Ein neuerer Ansatz die kontextorientierte Werkanalyse von Jan Distelmeyer versucht diese Frage zu klären
Als Grundlage dienen Publikums- und Kritikerrezeption auf der einen Seite und die Konstruktion des Autors aus Biografie Filmindustrie und kulturellem Umfeld auf der anderen Seite
Diese zweiseitige Annäherung erkennt das empirische Dilemma der Definition von auteur an und maßt sich auch keine Bestimmung dessen an was jetzt eigentlich das Werk von Autor XYZ ist
Viele andere Filmtheoretiker verfolgen heutzutage ähnliche Konzepte
Doch auch eine solch freie Handhabung kann das Problem nicht vollständig lösen da die wichtigsten Elemente variabel sind und sich so einer eindeutigen Aussage verschließen
Der Schwerpunkt kritischer Tendenzen liegt also zum Großteil in der Empirie
Einen Filmemacher als auteur anzuerkennen fordert uneingeschränktes Vertrauen in seine Aussagen wie viel Einfluss er auf seine eigenen Filme hatte
Da dies in Zeiten einer sehr starken Vermarktung aller möglichen mehr oder weniger unabhängigen Regisseure seitens von Filmindustrie und Verleih ein fast aussichtsloses Unterfangen ist ist ein Restzweifel und das stete Hinterfragen der auteur-Definition angebracht
weitere Quellenangaben zu diesem Abschnitt Kritik und Diskussion im Literaturverzeichnis
Einzelnachweise
Wichtige Auteur-Theoretiker
André Bazin
Andrew Sarris
Claude Chabrol
Dana Polan
Éric Rohmer
François Truffaut
Jan Distelmeyer
Jean-Luc Godard
Peter Wollen
Roland Barthes
Timothy Corrigan
Literatur
François Truffaut Une certaine tendance du cinéma français In Cahiers du cinéma <num> Januar
Übersetzung A Certain Tendency of the French Cinema In Bill Nichols Hrsg Movies and Methods Berkeley <num> S <num>-<num>
Jean-Luc Godard GodardKritiker München <num> S <num>-<num>
Jean-Luc Godard Einführung in eine wahre Geschichte des Kinos Hanser <num> ISBN <num>
Andrew Sarris Towards a Theory of Film History In Bill Nichols Hrsg Movies and Methods Berkeley <num> S <num>-<num>
Peter Wollen The Auteur Theory In Signs and Meaning in the Cinema London <num> S <num>-<num>
Roland Barthes Der Tod des Autors In Fotis Jannidis Gerhard Lauer Mathias Martinez Simone Winko Hrsg Texte zur Theorie der Autorschaft Stuttgart <num> S <num>-<num>
Timothy Corrigan A Cinema without Walls
Movies and Culture after Vietnam
New Brunswick <num> S <num>-<num>
Dana Polan Auteur Desire In
Nr <num> Auteurism <num>
Jan Distelmeyer Vom auteur zum Kulturprodukt
Entwurf einer kontextorientierten Werkgeschichtsschreibung
In Andrea Nolte Hrsg Mediale Wirklichkeiten Dokumentation des <num> Film- und Fernsehwissenschaftlichen Kolloquiums
Marburg <num> S <num>-<num>
Jean-Luc Godard Einführung in eine wahre Geschichte des Kinos Hanser <num> ISBN <num> S <num>
DateiAki Kaurismäki at Berlinale <num>jpg Aki Olavi Kaurismäki
<num> April <num> in Orimattila ist ein vielfach preisgekrönter finnischer Filmregisseur
Leben und Werk
Aki Kaurismäki studierte an der Universität Tampere Literatur- und Kommunikationswissenschaften
Neben diversen Aushilfsjobs etwa als Briefträger oder in der Gastronomie war er Herausgeber eines universitären Filmmagazins
Darüber hinaus schrieb er von <num> bis <num> Filmkritiken für das Magazin Filmihullu
Das erste Drehbuch folgte <num> für den mittellangen Film Der Lügner Valehtelija bei dem sein Bruder Mika Regie führte
Kaurismäkis Filme thematisieren häufig Schicksale von gesellschaftlichen Außenseitern in städtischen Zentren wie Helsinki
Sie sind nicht nur für ihre sparsamen Dialoge sondern auch für einen skurril-lakonischen Humor bekannt
Kaurismäki arbeitet regelmäßig mit einem festen Stamm befreundeter Schauspieler und Musiker die seine Filme auch stilistisch geprägt haben Matti Pellonpää Kati Outinen Kari Väänänen und Sakke Järvenpää
Als Reminiszenz an Alfred Hitchcock hat er in seinen Filmen gelegentlich Cameo-Auftritte was auch Hitchcock zu tun pflegte
In Deutschland wurden seine Filme zum ersten Mal <num> auf dem Filmfestival Grenzland-Filmtage in Selb gezeigt
Aki Kaurismäki führte dabei die Filme Der Lügner Calamari Union
und
Crime and Punishment
persönlich vor Während des Festivals schrieb er das Drehbuch für seinen Film
Schatten im Paradies den er <num> erneut persönlich bei den Grenzland-Filmtagen in Selb präsentierte
Dieser Film brachte ihm den internationalen Durchbruch
Ein Großteil der Filmmusik kam von der Band Nardis aus Erlangen die Kaurismäki <num> auf den Grenzland-Filmtagen kennengelernt hatte
Dem breiten deutschen Publikum bekannt wurde der finnische Regisseur durch seine Teilnahme an der Berlinale <num>
Für großes Aufsehen sorgte Kaurismäki im Herbst <num> als er sich weigerte seinen Film
Lichter der Vorstadt
als offiziellen finnischen Beitrag für eine Oscar-Nominierung in der Kategorie Bester fremdsprachiger Film zuzulassen obwohl das Drama von der finnischen Filmkammer einstimmig ausgewählt worden war
Kaurismäki begründete seine Ablehnung mit seiner seit Jahren vertretenen kritischen Haltung gegen den Irak-Krieg der USA
Zusammen mit seinem Bruder Mika Kaurismäki gründete er das Midnight Sun Film Festival im lappischen Sodankylä sowie die Verleihfirma Villealfa
Der Name geht zurück auf die Figur Ville Alfa den Protagonisten im Film Der Lügner
Gleichzeitig handelt es sich um ein Anagramm von
Alphaville einem Film von Jean-Luc Godard
<num> emigrierte Kaurismäki mit seiner Frau nach Portugal weil es in ganz Helsinki keinen Platz mehr gebe wo er seine Kamera noch postieren könne
Rainer Gansera der für die Zeitschrift epd Film mit dem Chef-Melancholiker des europäischen Autorenkinos <num> in Hof gesprochen hat zeigte sich auch von seinem Auftreten persönlich beeindruckt und beschrieb atmosphärisch
Als persönliche Leitbilder will Kaurismäki Bresson Ozu und Godard gesehen haben der Ausbildung an den Filmhochschulen seines Landes dagegen habe er nicht viel Positives abgewinnen können
Bei Pandora sind Ende <num> als Aki Kaurismäki DVD-Collection <num> Spielfilme und fünf Kurzfilme mit digital restaurierten Bildern in vier Boxen erschienen
<num> stellte Kaurismäki nach fünf Jahren mit
Le Havre
einen Spielfilm fertig der ihm wieder einmal eine Einladung in den Wettbewerb der Filmfestspiele von Cannes einbrachte
Der in Frankreich gedrehte Film handelt von einem Schuhputzer aus der gleichnamigen Hafenstadt der sich eines illegalen Flüchtlingskindes aus Afrika annimmt
Le Havre gewann in Cannes den FIPRESCI-Preis
Für den Spielfilm
Die andere Seite der Hoffnung
erhielt Kaurismäki <num> eine Einladung in den Wettbewerb der <num> Internationalen Filmfestspiele Berlin
Der Film spielt in Helsinki und erzählt von der Begegnung eines älteren finnischen Handelsvertreters dargestellt von Sakari Kuosmanen mit einem jungen syrischen Flüchtling Sherwan Haji
Der Film kam am <num> Februar <num> in die finnischen Kinos
Filmografie
Regisseur
<num> The Saimaa Gesture Saimaa-ilmiö - Dokumentarfilm mit seinem Bruder Mika
<num> Crime and Punishment Rikos ja rangaistus
<num> Der Clan - Geschichte der Frösche Klaani - tarina Sammakoitten suvusta - Co-Autor seines Bruders Mika
<num> Calamari Union
<num> Rocky VI - Kurzfilm
<num> Schatten im Paradies Varjoja paratiisissa
<num> Hamlet goes Business Hamlet liikemaailmassa
<num> Thru The Wire - Kurzfilm
<num> Rich Little Bitch - Kurzfilm
<num> Ariel
<num>
Likaiset kädet
- Produktion für das finnische Fernsehen
<num> Leningrad Cowboys Go America
<num> Das Mädchen aus der Streichholzfabrik Tulitikkutehtaan tyttö
<num> Vertrag mit meinem Killer I Hired a Contract Killer
<num> Those Were The Days - Kurzfilm
<num> Das Leben der Bohème Boheemielämää
La vie de Bohème
<num> These Boots - Kurzfilm
<num> Tatjana - Take Care Of Your Scarf Pidä huivista kiini Tatjana
<num> Total Balalaika Show
<num> Leningrad Cowboys Meet Moses
<num> Wolken ziehen vorüber Kauas pilvet karkaavat
<num> Juha
<num> Der Mann ohne Vergangenheit Mies Vailla Menneisyyttä
<num> Dogs Have No Hell - Kurzfilmbeitrag in
Ten Minutes Older The Trumpet
<num> Lichter der Vorstadt Laitakaupungin valot
<num> Le Havre
<num> Juice Leskinen
Grand Slam Bluesia Pieksämäen asemalla - Kurzfilm
<num> Tavern Man - Beitrag in Historic Centre
<num> Die andere Seite der Hoffnung Toivon tuolla puolen
Schauspieler
<num> Der Lügner Valehtelija - auch Drehbuchautor Film seines Bruders Mika
<num> The Worthless Arvottomat - auch Drehbuchautor und Regieassistent Film seines Bruders Mika
<num> Aaltra
<num> Estrada de Palha
<num> Vandaleyne Cameo
Auszeichnungen
DVD
Aki Kaurismäki Collection
Pandora Film <num> <num> DVDs mit insgesamt <num> Filmen aus den Jahren <num>-<num>
Literatur
Peter von Bagh
Kaurismäki über Kaurismäki Alexander Berlin <num> ISBN <num>-<num>-<num>-<num>-<num> Gespräche und Essays mit rund <num> Abbildungen
Beate Rusch Hrsg Schatten im Paradies
Von den Leningrad Cowboys bis Wolken ziehen vorüber - Die Filme von Aki Kaurismäki
Berlin Schwarzkopf
Schwarzkopf Verlag <num> ISBN <num>-<num>-<num>-<num> Fotografien von Marja-Leena Hukkanen mit Begleittexten von Aki Kaurismäki
Jochen Werner Aki Kaurismäki Mainz Bender <num> <num> S <num> sw-Abb ISBN <num>-<num>-<num>-<num> Analyse aller Kaurismäkifilme und ein langes Interview mit Kaurismäki
Ulrike Hanstein Unknown Woman geprügelter Held die melodramatische Filmästhetik bei Lars von Trier und Aki Kaurismäki Berlin Alexander <num> ISBN <num>-<num>-<num>-<num>
Ralph Eue und Linda Söffker Hrsg Aki Kaurismäki film <num> Mit Beiträgen von Lars-Olav Beier Harun Farocki Ulrich Gregor Anke Leweke und Jan Schulz-Ojala
Berlin Bertz
Fischer Verlag <num> <num> S <num> sw-Fotos
Bildsequenzen ISBN <num>-<num>-<num>-<num>
Reinhold Zwick Wolken ziehen herauf und vorüber
Strukturen des Komischen in der Bibel und bei Aki Kaurismäki
in StOrthJValentinRZwick Hrsg Göttliche Komödien
Religiöse Dimensionen des Komischen im Kino Film und Theologie Bd <num> Köln <num> S <num>-<num>
Reinhold Zwick Selig die Armen in den Wohncontainern
Aki Kaurismäki und seine Tragikomödie Der Mann ohne Vergangenheit
in Stimmen der Zeit <num> <num> S <num>-<num>
Reinhold T Schöffel Grenzland Filmtage
Programm
Grenzlandfilmtage eV Wunsiedel <num> S <num>-<num>
Weblinks
Aki Kaurismäki von Stadtbibliothek Orimattila finnischenglisch
Aki Kaurismäki - Die Helden diesseitig und einsam Dietrich Kuhlbrodt epd Film <num><num>
Begrabt mein Herz an der Müllkippe Andreas Kilb Die Zeit <num><num>
Wo ich lebe ist immer ein Schatten Interview im Stadtmagazin Zitty <num>
Kino der Lakonik Filmzyklus in Zürich
Einzelnachweise
Ralph Eue Biografische Skizze In Ralph Eue und Linda Söffker S <num>-<num> Grenzland Filmtage Programm Grenzlandfilmtage eV Wunsiedel <num> S <num>-<num> epd Film <num><num> S <num>Eue S <num> epd Film <num><num> S <num>Hopewell John
bei varietycom <num> Mai <num> aufgerufen am <num> Mai <num> Aunimo Rane
bei demokraattifi <num> April <num> abgerufen am <num> März <num> Taavitsainen Iikka
bei savonsanomatfi abgerufen am <num> April <num> httpwwwimdbcomtitlett<num> Rezension von Dietmar Kammerer taz vom <num> Oktober <num> abgerufen <num> September <num>
Anime jap
im Deutschen häufig
Plural Animes bezeichnet in Japan produzierte Zeichentrickfilme
In Japan selbst steht Anime für alle Arten von Animationsfilmen und -serien für die im eigenen Land produzierten ebenso wie für importierte
Er bildet das Pendant zum Manga dem japanischen Comic
Japan besitzt die umfangreichste Trickfilmkultur weltweit
Definition und Begriffsgeschichte
Im Japanischen kann Anime jegliche Animationsfilme bezeichnen sowohl die aus dem eigenen Land als auch aus dem Ausland
Außerhalb Japans wird der Begriff ausschließlich für Animationsfilm japanischer Herkunft verwendet
Historisch wurden Animationsfilme in Japan lange Zeit nicht Anime genannt
Zu Beginn des <num> Jahrhunderts gab es zunächst die Worte senga Linienkunst und kuga Klapp-Bilder vgl Daumenkino dekobō shin gachō schelmische neue Bilder oder chamebō-zu verspielte Bilder Später kamen manga eiga
Manga-Filme und dōga
bewegte Bilder auf
Erst in den <num>er Jahren tritt das Wort Anime in Japan zusammen mit der Wortschöpfung Japanimation auf
Letztere wird ausschließlich für die damals erstmals stark wachsende eigene Animationsbranche verwendet Anime entstand als eine Verkürzung des japanischen Lehnwortes animēshon
von
Während animēshon eher als Bezeichnung für höher geachtete Animationskunst und Kinofilme verwendet wurde wurde dessen Kurzform vor allem für die ab den <num>er entstehenden günstiger produzierten Fernsehserien verwendet Letztlich setzte sich Anime als Bezeichnung aller Animationsproduktionen durch
Die anderen Begriffe blieben nur in Nischen erhalten Als Bezeichnung nur für japanische Animationsfilme und -serien hat sich der Begriff seit den <num>er Jahren in den USA und Europa durchgesetzt Im englischen Sprachraum wurde seit Ende der <num>er Jahre in der kleinen Fanszene und von ersten kommerziellen Vertrieben zunächst häufiger Japanimation verwendet was jedoch zu Verballhornungen und Missverständnissen führte
So wurde dieses Wort um <num> von dem aus Japan übernommenen kürzeren Anime abgelöst
Im wissenschaftlichen oder journalistischen Diskurs ist die genaue Abgrenzung zwischen Anime und Animation allgemein jedoch umstritten
auch wenn Anime und japanischer Animationsfilm meist synonym verwendet werden
So nennt Thomas Lamarre eine Abgrenzung von Full Animation und Limited Animation im japanischen Diskurs
Anime besonders Fernseh-Anime in der einfachen kostengünstig produzierten Form der <num>er Jahre wird dann als eine Form der Limited Animation aufgefasst
Produzenten von Full Animation wollen sich davon abgrenzen
Beispielsweise lehnt das Studio Ghibli den Begriff Anime für ihre Filme ab und verwendet stattdessen manga eiga Aufwändige Filme und Fernsehproduktionen haben jedoch gemeinsam dass die Ästhetik traditioneller Animationstechniken fast immer erhalten wird auch wenn vielfach Computeranimationen zum Einsatz kommen
Reine Computeranimationsfilme denen diese Technik auch anzusehen ist und die nach Realismus streben kommen zwar vor sind aber eine Ausnahme Stevie Suan und José Andrés Santiago Iglesias nennen eine Reihe von Stil-Merkmalen die japanischen Fernsehproduktionen und solchen mit japanischem Einfluss zu eigen sind Eine durchgehende Erzählung über alle Folgen der Gebrauch von Cliffhangern und deren Auflösung durch Eukatastrophen reduziertes und ikonisches Charakterdesign größere Vielfalt in der Farbpalette Gebrauch von Limited Animation und die Erzeugung eines Raumeindrucks durch Bewegung sowie der Einsatz vieler Schnitte Kameraeinstellungen und Montagen zur Darstellung vieler Perspektiven und Details einer Szene
Die Gesamtheit dieser Merkmale fassen Suan und Iglesias unter dem Begriff animesque zusammen
Ein animesques Werk wird von Fans als Anime erkannt da es die erzählerischen und formalen Erwartungen erfüllt die mit dem japanischen Animationsfilm verbunden werden Brian Ruh verweist neben den von Iglesias genannten Stilmerkmalen auf die Transnationalität des Mediums Anime die sich in dessen Geschichte als auch in international verständlichen Designs äußert Ähnlich beschreiben auch andere Autoren ein Verständnis von Anime als in einen Medienmix eingebundene Fernseh-Serienproduktionen mit auch in ihren Filmadaptionen wiedererkennbaren im Fernsehen entstandenen Stil- und Erzählmerkmalen Daneben gibt es Produkte des japanischen Animationsfilms die von einigen Rezipienten nicht als Anime angesehen werden sondern einem unbestimmten Alternativen japanischen Animationsfilm oder nur allgemein Animationsfilm zugerechnet werden
Jonathan Clements weist ebenfalls auf mehrere Abgrenzungsunschärfen des Begriffs hin Neben der technischen zwischen Full und Limited Animation gibt es Autoren die Anime historisch abgrenzen als japanischen Animationsfilm ab den Fernsehserien der <num>er Jahre
Japanischer Animationsfilm aus der Zeit davor wird dann nicht als Anime bezeichnet obwohl die frühen Filme von großer Bedeutung für die späteren Produktionen waren
Weitere Unschärfen ergeben sich aus dem umfangreichen Prozess von Produktion Vertrieb und Konsum
So sind einige ausländische - insbesondere US-amerikanische - Trickfilmproduktionen unter japanischer Mitwirkung oder sogar großteils in Japan entstanden andererseits waren japanische Unternehmen Auftraggeber für Animationsarbeit in anderen Staaten und schließlich sind bei der Lokalisierung Vertrieb und Vermarktung ausländischer Produktionen japanische Firmen beteiligt
All die damit in Verbindung stehenden Werke können daher auch als Teil der japanischen Animationsfilmindustrie beziehungsweise von dessen Geschichte begriffen werden
Und schließlich gehören zu Anime nicht nur die Objekte die hergestellten und verkauften Werke sondern auch die Ereignisse der Vorführung und des Konsums Steven T Brown geht so weit die Bedeutung des Begriffs Anime in der Präsentation und Anordnung der Informationen bei der Vorführung und in der Interaktion des Rezipienten mit dem Werk zu suchen
In der Beschreibung von Anime als Medium wird auch oft darauf hingewiesen wie stark sich der japanische Animationsfilm von dem unterscheidet was westliche Zuschauer von Animationsfilmen - insbesondere amerikanischen Cartoons oder Filmen von Walt Disney - erwarten
Viele Animes sind nicht für Kinder gemacht manche sogar pornografischer Natur erzählen dramatische oder actionreiche Geschichten und bedienen eine große Vielfalt an Genres
Im Vergleich zu vielen im Westen erfolgreichen Trickfilmen kommen Musicaleinlagen Tierfiguren und Slapstick-Humor deutlich seltener vor
Trotz dieser häufig genannten Merkmale beziehungsweise auffälligen Unterschiede werden diese nicht zur Definition herangezogen
Als Anime um <num> herum in den USA immer größeren Zuspruch fanden zugleich aber Vorurteile gegenüber einem als für Kinder gefährlichen Kulturimports herrschten wurde Anime auch pejorativ verwendet - vor allem von solchen Vertrieben die selbst japanische Animationsfilme importierten und ihre Produkte vor den Vorurteilen schützen wollten
Historische Entwicklung
Zu Beginn der <num>er Jahre kamen erste westliche Trickfilme nach Japan
Die ersten japanischen Nachahmer sind aus dem Jahr <num> bekannt in dem die Pioniere Oten Shimokawa Junichi Kōuchi und Seitarō Kitayama ihre ersten Filme aufführten
Aus dieser Zeit sind nur sehr wenige Werke erhalten
Ab den <num>er Jahren nahm die Produktion zu
Die entstandenen Kurzfilme waren meist Komödien Lehrfilme oder zeigten japanische und chinesische Mythen
In den <num>er Jahren wurden zunehmend Propagandafilme produziert die vor amerikanischem Einfluss warnten und Japans Kriege in China und die Expansion im Pazifik vorbereiteten und begleiteten
Diesem Ziel diente auch der erste abendfüllende Animefilm
Momotarō Umi no Shimpei
Die in schwarz-weiß erzählte Geschichte von Tieren die Pazifikinseln von der britischen Kolonialmacht befreien und ihnen die japanische Kultur bringen kam <num> nicht lange vor der Kapitulation in die Kinos
Nach Ende des Krieges dauerte es über zehn Jahre ehe <num> mit
Hakujaden
wieder ein abendfüllender nun farbiger Anime in die japanischen Kinos kam
Er war der Beginn einer Reihe von Filmen des Studios Toei Animation die als Klassiker vor der Zeit des Fernseh-Animes gelten und erheblichen Einfluss auf die späteren Produktionen hatten
Ihre Ästhetik war bereits vom zeitgenössischen Manga beeinflusst und an den Produktionen waren viele beteiligt die später eigene Studios gründeten und dabei ihre ersten Erfahrungen von Toei mitnahmen
Eine wichtige Figur der Anime-Geschichte ist ähnlich wie beim Manga Osamu Tezuka
Nachdem er an einem Spielfilm mit Toei Animation gewirkt hatte wollte der bereits erfolgreiche Mangaka die eigenen Serien verfilmen und schuf schließlich <num> mit
Astro Boy
die erste Anime-Fernsehserie mit halbstündigen Folgen
Sein Studio produzierte weitere Serien die auf Tezukas Geschichten basierten darunter den mit amerikanischer Finanzierung entstandenen ersten farbigen Fernsehanime
Kimba der weiße Löwe
Ab Ende der <num>er Jahre schuf Tezuka dann anspruchsvollere und experimentellere Filme sowie einige der ersten erotischen Animefilme
Tezuka war - wie auch bei seinen Mangas - noch stark von den Filmen Walt Disneys und deren Ästhetik beeinflusst
Seine eigenen Werke hatten wiederum großen Einfluss auf die ihm nachfolgenden Filmschaffenden entweder in Anlehnung oder Abgrenzung seiner Stile und Arbeitsweisen In den späten <num>er und den <num>er Jahren entstanden vor allem Science-Fiction-Serien und mit ihnen wuchs die erste Generation an Fans auf die ab den <num>er Jahren selbst als Produzenten in der Anime-Industrie aktiv wurde Ebenso ab Ende der <num>er Jahre entstanden im bisher männlich dominierten Medium die ersten Serien die sich an Mädchen richteten
Ribon no Kishi
<num> von Tezuka und
Mila Superstar
<num> zählten zu den ersten mit denen der Entstehung des Shōjo-Mangas auch dessen Adaptionen als Anime folgten
Diese Serien brachten neuen Themen in das Medium insbesondere Emanzipation Selbstfindung und Liebesgeschichten
In diesem Umfeld entstanden neue Genre In den <num>ern die von sich magisch verwandelnden Mädchen erzählenden Magical-Girl-Serien in den <num>ern kamen Geschichten über homoerotische Beziehungen zunehmend aus dem Manga auch in den Anime und generell fanden ästhetische Prinzipien aus Serien für Mädchen stärkere Verbreitung darunter die Darstellung schöner Jungen als Bishōnen
Seit den <num>er Jahren kamen Animes ins europäische und amerikanische Kino zunächst vor allem Kinderserien die auch in Koproduktion mit westlichen Sendern und Studios entstanden
Gegenüber erwachseneren actionhaltigen Stoffen bestanden große Vorbehalte In den Videotheken wurden zunächst vor allem pornografische und erotische Titel vertrieben was Anime generell einen entsprechenden Ruf gab Das änderte sich ab Ende der <num>er unter anderem mit dem Erfolg des Science-Fiction-Films
Akira
im Kino in den <num>ern dann mit den Filmen des Studio Ghibli und mit international erfolgreichen Fernsehserien wie
Sailor Moon
und
Dragon Ball
sodass das Medium um das Jahr <num> herum international seinen Durchbruch erlebte und eine große Fangemeinde gewinnen konnte
Inhalte Genres und Zielgruppen
Animes decken ein breitgefächertes Themenspektrum für alle Altersstufen ab
Geschichten sind oft komplexer und vielschichtiger als bei vielen westlichen Trickfilmproduktionen üblich
Es findet mehr Charakterentwicklung statt und auch der Tod wichtiger Charaktere kann vorkommen
Auch wenn grundsätzlich alle möglichen Themen auftreten können so sind doch besonders solche mit Bezug zum japanischen Alltag oder der japanischen Kultur verbreitet
Die kann zum einen Sport und Kunst Probleme des Alltags und dessen Regeln oder des Lebens im modernen technisierten und in den Metropolen dicht besiedelten Landes sein zum anderen traditionelle Künste Themen des Buddhismus und Shinto und der japanischen Geschichte und Mythologie
Diese Themen werden nicht selten gemischt mit Science-Fiction- und Fantasy-Elementen und die meisten Werke lassen sich nicht klar einem einzigen Genre zuordnen Auch gibt es seit den <num>er Jahren auch immer wieder Werke die die Fanszene selbst in den Fokus nehmen und sich wiederum vor allem an diese als Zielgruppe wenden
Antagonisten sind häufig differenziert und verfügen über eine Hintergrundgeschichte die ihre Handlungen erklärt
Klischees über typische Bösewichte werden gebrochen und beispielsweise gerade die Gegenspieler als besonders schön dargestellt
Von Literaturverfilmungen z B
Das Tagebuch der Anne Frank
oder
Heidi
über Horror bis zu Romanzen werden nahezu alle Bereiche und Altersklassen abgedeckt
Auch gibt es Genres die ausschließlich in Anime und Mangas vorkommen oder in diesen Medien entstanden sind so zum Beispiel Mecha-Serien über überdimensional große meist von Menschen gesteuerte Roboter
Pornographische Animes sogenannte Hentai machen nur einen kleinen Teil des japanischen Kaufvideo-Marktes aus im Fernsehen und im Kino werden diese in Japan überhaupt nicht gezeigt
Viele Animes beinhalten jedoch erotische Elemente ohne dem Hentai-Genre zugeordnet werden zu können insbesondere die des Genres Etchi
Solche sowie Serien mit hohem Anteil von Gewalt oder anspruchsvollen Inhalten laufen im japanischen Fernsehen im Nachtprogramm und finanzieren sich in der Regel nicht durch die Ausstrahlung sondern durch die mit Fernsehausstrahlung beworbenen DVD-Verkäufe
Erotische Geschichten und der relativ freizügige Umgang mit Sexualität in der Populärkultur haben in Japan eine lange Tradition so gab es in der Edo-Zeit viele solche Ukiyo-e Shunga genannt
n Hentai als auch in Etchi-Manga sind wie in der japanischen Erotik allgemein üblich Sexszenen oft in eine humoristische oder parodistische Erzählung eingebettet
Erotik ist in Japan stark geprägt von der unter der amerikanischen Besatzung entstandenen Gesetzgebung die die Darstellung des erwachsenen Genitalbereichs und andere anstößige Inhalte unter Strafe stellte
<num> des jap Strafgesetzbuchs
Dies wurde von vielen Künstlern umgangen indem die Figuren und ihre Genitalien kindlich gezeigt wurden
Zusammen mit der Kawaii-Ästhetik beförderte das die Entstehung vieler erotischer und pornografischer Geschichten mit kindlichen Figuren und die Etablierung der Genres Lolicon und Shotacon
Auch wenn die Auslegung der Gesetze gelockert wurde blieb diese Strömung erhalten
Andere Wege die Zensurgesetzgebung zu umgehen sind die Verwendung von Balken oder Verpixelung Auslassungen oder stark reduzierte symbolhafte Darstellung von Geschlechtsorganen
International waren erotische Anime zeitweise kommerziell deutlich erfolgreicher und verbreiteter als andere Genres was zur Legende führte alle Anime seien pornografisch
Dieser Eindruck ist jedoch auch Ergebnis der Stereotype des westlichen Publikums und wirkte vermutlich auch auf die japanischen Produktionen zurück die wiederum an amerikanischen Filmen orientierend den Frauen größere Brüste und den Männern mehr Muskeln gaben
Nacktheit kann darüber hinaus auch jenseits sexueller Szenen vorkommen in Alltags- oder Kinderserien da es in solchen Situationen in Japan nicht als anstößig gilt
Während sich Fernsehproduktionen häufiger an Kinder richten ist die Zielgruppe des Videomarktes ältere Jugendliche und Erwachsene
Anime- und Manga-spezifische Genre
Etchi Abgeleitet von der Aussprache des englischen Buchstabens H für Hentai Japanisch für unanständige Sexualität
Diese Anime enthalten nach der westlichen und insbesondere der deutschen Definition nur leicht sexuelle Andeutungen
In Japan sind Etchi und Hentai das Gleiche was sich vor allem durch die Wortbildung selbst erklären lässt
Gourmet Geschichten über Kochen und Essen in denen vor allem Gourmets Restaurantkritiker oder Köche im Mittelpunkt stehen
Harem Lose definiertes Genre in dem der Protagonist der Handlung von mehreren oder gar einer Vielzahl weiterer Charaktere anderen Geschlechts umgeben ist die sich zu ihm hingezogen fühlen
Hentai japanisch für abnormal oder pervers
Dieser Begriff wird hauptsächlich von westlichen Zusehern für Anime mit pornographischen oder erotischen Inhalten genutzt
In Japan jedoch sind die Begriffe Poruno oder Ero gebräuchlich um auf solches Material hinzuweisen
Isekai bedeutet soviel wie andere Welt
Hierbei gelangen ein oder mehrere Charaktere aus verschiedensten Gründen aus der realen Welt in eine andere
Diese kann beispielsweise ein Videospiel oder eine Fantasiewelt sein
Josei ist das weibliche Gegenstück zu Seinen
Behandelt oft den Alltag oder auch das Berufs- und Liebesleben von jungen Frauen
Kodomo jap für Kind Produktionen für jüngere Kinder
Magical GirlMahō Shōjo jap für magisches Mädchen Geschichten über Mädchen die sich in magische Kriegerinnen verwandeln können
Mah-Jongg Geschichten um das Spiel Mah-Jongg
Mecha Anime und Manga in denen riesige Roboter vorkommen
Seinen jap für junger Mann Primäre Zielgruppe sind Männer im Alter von <num> bis <num> Jahren
Es werden meist anspruchsvollere erotischere oder gewalthaltigere Inhalte thematisiert
SentaiSuper Sentai jap für Kampfteam Bezieht sich auf jede Sendung mit einem Team aus Superhelden
Shōjo jap für Mädchen Sendungen für weibliche Jugendliche oft auch Liebesgeschichten
Shōnen jap für Junge Produktionen für männliche Jugendliche oft auch den Genres Action Science-Fiction und Fantasy zuzuordnen
Shōnen Ai jap für Jungen-Liebe Bezeichnung für Manga und Anime deren Thema die Liebe und Romantik zwischen männlichen Charakteren ist
Diese Bezeichnung ist in Japan wegen der Andeutungen auf Pädophilie nicht gebräuchlich und wurde daher durch den Begriff Boys Love oder ähnliche ersetzt
Sport Geschichten in denen eine Sportart im Mittelpunkt steht
Üblicherweise wird die Entwicklung eines Sportlers von den Anfängen bis zur professionellen Karriere verfolgt
Yaoi wie Shōnen Ai hat aber meist auch eine sexuelle Beziehung zum Thema
Zielgruppe sind Frauen
Yuri bezieht sich auf Anime und Manga die Liebe und Romantik zwischen weiblichen Charakteren zum Inhalt haben
Produktion und Arbeitsbedingungen
Traditionell entstehen Animes wie auch Trickfilme in anderen Ländern in Cel-Animation
Die bemalten Folien Cel werden vor einen Hintergrund gelegt und einzeln abgelichtet
Die Zahl der produzierten Folien und Einzelbilder pro Sekunde hängt von Budget und der beabsichtigten Qualität beziehungsweise Realismus der Bewegung ab
Tendenziell sind Kinofilme aufwändiger und höherwertiger mit mehr Cels für die gleiche Zeit produziert als Fernsehserien
Auch Produktionen direkt für den Videomarkt haben in der Regel eine höhere Qualität als für das Fernsehen
Cel-Animation wurde seit den <num>er Jahren zunehmend von Computeranimationen verdrängt Seit den Fernsehserien ab Beginn der <num>er Jahre - für manche aus diesem Grund die eigentliche Geburt von Anime - herrscht Limited Animation als Animationsprinzip vor
Bei den Produktionen von Kinofilmen in den Jahren zuvor wurde noch nach dem Vorbild Disneys Full Animation angestrebt das heißt möglichst realistische Darstellung und bestmögliche Illusion der Bewegung wobei eine größere Zahl von Bildern pro Sekunde und entsprechender Aufwand eingesetzt wird
<num> unterschiedliche Bilder pro Sekunde sind dafür üblich <num> in der Spitze
Dieser Ansatz ist unüblich geworden nur Kinoproduktionen insbesondere von Studio Ghibli verfolgen diesen noch und wurde weitgehend durch Limited Animation abgelöst
Diese kommt mit nur durchschnittlich <num> Bildern pro Sekunde aus
Der Eindruck von Bewegung wird nicht nur durch unterschiedliche Bilder sondern auch Arrangement der Bilder und Schnitte erzeugt
So kann der Eindruck von Bewegung anstatt durch verschiedene Bilder durch das Verschieben von Vorder- und Hintergrund gegeneinander erzeugt werden
In Actionszenen wechseln eher Standbilder in ausdrucksstarken Posen in schnellen Schnitten als dass Bewegungen tatsächlich gezeigt werden Raumtiefe kann durch das Übereinanderlegen der Folien und deren Überschneidung zumindest angedeutet werden Bildfolien werden häufig wiederverwertet
Zu diesem Zweck verwenden Studios Folienbibliotheken der einzelnen Figuren in unterschiedlichen Positionen und Bewegungen die erneut eingesetzt werden können
Die deutliche Kostenersparnis dabei war zunächst einer der wichtigsten Gründe dafür
Osamu Tezuka hat seine ersten Folgen für nur <num> Yen jeweils verkauft
Doch auch als ab den <num>er Jahren die Studios langsam mehr Geld zur Verfügung hatten wurde von diesem Prinzip nicht abgewichen
Stattdessen wurden wie schon von Beginn an von Tezuka dessen künstlerische Möglichkeiten erkundet oder zusätzlicher Aufwand in Hintergründe und Designs investiert
Als in den <num>er Jahren erstmals Computeranimationen eingesetzt wurden gehörte die japanische Filmwirtschaft zu den ersten Anwendern
Seitdem wurde immer wieder mit <num>D-Animation experimentiert
Anders als in den USA konnte die Computeranimation aber nicht die traditionelle <num>D-Ästhetik ablösen reine <num>D-Animationsfilme aus blieben eine Seltenheit
Stattdessen werden Animationen als Effekte in Szenen klassischer Animation eingesetzt beispielsweise Lichteffekte und am Computer animierte Bildelemente werden in einer Weise gerendert die sie wie handgezeichnet erscheinen lässt
Besonders letzteres ist seit Ende der <num>er Jahre durch neue Software einfacher umsetzbar geworden und wurde daher zunehmend in Bildelementen eingesetzt die mit der Hand gezeichnet zu aufwändig oder nur schwer zufriedenstellend umzusetzen sind
Insbesondere die Charaktere aber bleiben handgezeichnet und die Ästhetik der traditionellen Cel-Animation wird beibehalten
Zugleich bringt der Einsatz von Computern neue Möglichkeiten für die Einbindung von Fotografien und Rotoskopie
Die Herstellung findet nicht nur in Japan statt sondern aus Kostengründen auch in anderen asiatischen Ländern Amerika und Europa
Die wichtigsten Nachunternehmer sitzen in Korea China und Thailand
Ausgelagert werden vor allem die Herstellung von Zwischenphasenbildern und die Koloration
Die Entwicklung von Drehbüchern und Storyboards Designs und Schlüsselbildern bleibt in der Regel in Japan
Wichtigste Einnahmequelle der Studios waren in den <num>er Jahren an erster Stelle das Merchandising danach Senderechte und in deutlich geringerem Umfang Kinoeinnahmen und Werbefilme
Hauptabnehmer ist das Fernsehen gefolgt vom Kino und dem Videomarkt an letzter Stelle
Fur eine einzelne Folge werden etwa <num> Millionen Yen in früheren Zeiten eher <num> Millionen und anderthalb Monaten Produktionszeit aufgewendet
In den <num>er Jahren wurden jedes Jahr <num> bis <num> Fernsehserien und <num> bis <num> Kinofilme produziert
Laut einer im Jahr <num> durchgeführten Studie arbeiten japanische Anime-Zeichner im Durchschnitt <num> bis <num> Stunden pro Arbeitstag bzw <num> Stunden pro Monat bzw <num> freie TageMonat
Animatoren verdienen pro Jahr durchschnittlich Mittelwert <num> Millionen Yen ca <num>
bzw am häufigsten Modalwert <num> Mio Yen <num>
angefangen bei Einstiegspositionen wie Zwischenzeichnern mit <num> Mio Yen <num>
über Schlüsselzeichner mit <num> Mio Yen <num>
und Storyboarder<num>D-Animatoren mit <num> Mio Yen <num>
bis zu Regisseuren mit <num> Mio Yen <num>
Zeichner werden häufig nach einem Schema bezahlt bei dem sie zusätzlich zu einem festen Lohn noch nach fertiggestellten Einzelbildern bzw -szenen bezahlt werden
Bildsprache
DateiMahurijpg DateiVergleich zwischen Manga und Fotojpg
Die häufig anzutreffenden Stile Bildsprache und Symbolik von Animes sind zum einen geprägt durch die lange Zeit übliche Produktion als Cel-Animation zum anderen durch Einflüsse von Mangas und insbesondere in der frühen Zeit aus dem amerikanischen und französischen Film
Ähnlich wie im Manga sind die handelnden Figuren einfach und stilisiert gehalten während die Hintergründe detaillierter und realistischer gezeichnet sind
Auf diese Weise wird sowohl die Identifikation mit den Charakteren erleichtert als auch das Eintauchen in die Welt der Geschichte Der Detailreichtum der Hintergrundbilder kann insbesondere in Kinoproduktionen ein großes Ausmaß erreichen und bildet einen entsprechenden Kontrast zu den Charakteren im Vordergrund Das Charakterdesign ist stark vom Manga beeinflusst und entspricht beispielsweise oft dem Niedlichkeitskonzept Kawaii
Bei älteren Charakteren oder Werken für erwachseneres Publikum kommt auch das reifere nicht niedliche Designprinzip kirei vor
Darüber hinaus finden japanische Idealvorstellung von schönen Frauen und Männern Bishōjo und Bishōnen Anwendung und in der Charakterentwicklung werden Archetypen Stereotype und Klischees verwendet von denen sich manche von denen anderer Kulturkreise unterscheiden
Daneben ist - im Unterschied zum westlichen Animationsfilm - nicht die realistische Bewegung Ziel der Animation sondern der Übergang zwischen ausdrucksstarken Posen
Dies lässt sich sowohl auf Kostenzwänge in der Produktion in der stehende Bilder günstiger sind als auch auf eine japanische ästhetische Tradition zurückführen die sich beispielsweise auch im Kabuki-Theater zeigt in dem Posen ebenfalls eine wichtige Rolle einnehmen Die einfach gehaltene günstigere Animationstechniken der sogenannten Limited Animation prägten den Anime
Erzählerisch können durch die zurückhaltende Animation der Geschichte und den Charakteren größeres Gewicht gegeben werden als Bewegung Action und visuellem Humor Limited Animation geht mit einer sich von Full Animation unterscheidenden Ästhetik einher Neben der Betonung von Posen der Figuren auch eine große Bedeutung von Rhythmus bei Einsatz und Wiederverwendung der Einzelbilder und Schnitten
Durch die Posen fällt dem vor der Animation stattfindende Charakterdesign ein größeres Gewicht zu als bei der auf Bewegung fokussierten Full Animation
Diese Hinwendung zu den beziehungsweise Betonung von einzelnen Charakteren dient zugleich dem multimedialen Einsatz der Figuren die sich leichter aus ihrer Serie herauslösen und in anderen Kontexten verwenden und vermarkten lassen
Während die Techniken der Limited Animation für manche nicht als richtige Animation gelten sind sie für andere eine modernere weiterentwickelte Animation die sich von der Nachempfindung des Realfilms gelöst hat und in der sich sowohl kommerzielle Massenwerke als auch experimentelle Kunst realisieren und manchmal kaum noch unterscheiden lassen
Thomas Lamarre nennt einige Einsätze dieser Techniken wie sie beispielsweise bei Gainax geschehen wegen ihrer besonderen Ästhetik und dem ausgefeilten Einsatz von Schnitt und Rhythmus sogar Full Limited Animation Hiroki Azuma macht die Folienbibliotheken der Studios als eine frühe Form von Datenbanken zu einem wichtigen Element seiner Analyse der Anime-Fankultur und deren Verhältnis zu Technik und Information Die im Anime übliche flächenhafte Ästhetik die durch stilisierte Figuren und die Techniken der Cel-Animation mit ihrer Arbeit in Schichten entsteht wird mit dem Begriff Superflat in Verbindung mit einem größeren Trend in der japanischen Kunst und Populärkultur gebracht der von Holzschnitt bis zu Computerspielen und Manga reicht
Über die international bekannte Ästhetik von Anime hinaus gibt es auch viele Werke die diesen Vorstellungen nicht entsprechen
Dazu können schon ältere Anime-Klassiker zählen die nicht mehr heutigen Stilen ähneln aber auch Puppentrickfilme von Kihashiro Kawamoto oder Animation mit Silhouetten und Schattenrissen
Besonders im Animationsfilm bis zum Zweiten Weltkrieg sind die Einflüsse des japanischen Theaters und Kunst in der Vorliebe zu flächiger Bildgestaltung und für Choreografie deutlich zu erkennen
Anime in Japan
Anime sind ein fester Bestandteil des japanischen Kulturgutes
Zu den erfolgreichsten Kinofilmen in Japan zählen viele Animes so
Prinzessin Mononoke
Pokémon Der Film
und
Chihiros Reise ins Zauberland
Nach einer Umfrage sind die <num> beliebtesten Zeichentrickserien in Japan alle Anime mit Ausnahme von
Tom und Jerry
Veröffentlichungsarten
Neben Fernsehserien und Kinofilmen werden Animes seit den frühen <num>er Jahren als Original Video Animation kurz OVA für den Kaufvideo- und DVD-Markt produziert
Die Zielgruppe sind meist junge Erwachsene daher sind die Inhalte in der Regel mit viel Fanservice versehen
Diese wurden aber weitestgehend durch Mitternachtsanime ersetzt
Seit <num> gibt es auch Serien direkt für das Internet Original Net Animation ONA genannt
Fernsehen
Anime-Fernsehserien haben für gewöhnlich <num>-<num> <num>-<num> sowie seltener <num> oder mehr Folgen so dass bei wöchentlicher Ausstrahlung eine Laufzeit von einem viertel halben oder ganzen Jahr erreicht wird
Ein solches Vierteljahresintervall wird als cours
kūru bezeichnet
Die cours sind dabei saisonal d h es gibt Winter- Frühlings- Sommer- und Herbst-Cours die im Januar April Juli bzw Oktober beginnen
Die meisten Anime-Serien sind nicht als Endlosserien ausgelegt obwohl insbesondere Verfilmungen langer Manga-Serien auf weit mehr als <num> Folgen kommen können
Im Jahr <num> wurden sieben Serien gesendet dies wird generell als der Beginn von Anime-TV-Serien angesehen
<num> wurde die <num>er-Grenze mit <num> Serien gebrochen
<num> wurde die <num>er-Grenze mit <num> Serien erreicht
Mit <num> Serien wurde die <num>er-Grenze im Jahr <num> erreicht
Seitdem hat sich die Anzahl der Serien mehr oder weniger etabliert jedoch gab es Jahre wie <num> und <num> in denen die <num>er-Grenze erreicht wurde
Der Anstieg der Anime-Anzahl in den <num>ern ist darauf zurückzuführen dass seit <num> die Mitternachtsprogrammplätze für Anime verwendet werden aber auch darauf dass durch den großen Erfolg und die Kontroverse von
Neon Genesis Evangelion
immer mehr Studios Videounternehmen und Verlage Werke produzieren ließen Diese schließen sich dann oft mit Merchandising-Partnern zu Produktionskomitees
seisaku iinkai zusammen und kaufen einen Mitternachtsprogrammplatz - daher auch als Mitternachtsanimes
shinya anime bezeichnet - bei mehreren Sendern üblicherweise für ein bis zwei cours
Der größte Teil dieser Programmierungen geschieht auf Regionalsendern die keinem der großen Networks angeschlossen sind
Da diese auf UHF-Band ausstrahlen werden derartige Anime auch UHF-Anime UHF genannt
Mitternachtsanimes erreichen durchschnittliche Einschaltquoten von etwa <num>
während <num> bis <num>
schon außergewöhnlich hoch sind
Einschaltquoten spielen bei Mitternachtsanimes und damit den meisten Animes seit den späten <num>ern kaum eine Rolle sondern die Ausstrahlung dient der Werbung für die DVD- oder Blu-ray-Veröffentlichungen mit denen und den Merchandise-Artikeln der Gewinn gemacht wird
Abhängig von deren Verkaufszahlen entscheidet sich dann ob weitere Staffeln produziert werden
Viele der Anime die ein bestehendes Werk adaptieren dienen letztendlich aber auch der Bewerbung der Vorlage so dass für das auftraggebende Produktionsunternehmen auch die Animeverkäufe zweitrangig sein können sofern die Vorlagenverkäufe anziehen was sich daran äußert dass teilweise auch nur wenig erfolgreiche Anime Fortsetzungen bekommen können
Anders sieht dies bei am Tage ausgestrahlten Animes aus die meist langläufig sind über zwei cours und sich zudem auch entweder an ein junges oder ein Familienpublikum richten
Seit der Einführung der Mitternachtsanime hat sich die Anzahl der Serien mit hohen Einschaltquoten verringert und auch die Art der Serien im Tagesprogramm hat sich verändert
Anime mit den höchsten Einschaltquoten
Anime mit den höchsten Heimvideoverkäufen
Durch die sich erholende Wirtschaft während der <num>er Jahre die starke Berichterstattung über die steigende Beliebtheit von Animes im Ausland und den Moe-Boom investierten aber auch branchenfremde Unternehmen wie Finanz- und neue IT-Unternehmen in diesen früheren Nischenmarkt
Der Rückgang seit <num> wird auf die sinkenden Geburtenraten und die wirtschaftliche Rezession zurückgeführt
Japanische Fernsehsender gehen aber auch dazu über den ausländischen Markt direkt zu beliefern
In den USA wird der Rückgang der Marktgröße für Animes von <num> Mrd
Dollar im Jahr <num> auf <num> Mrd
Dollar für <num> hauptsächlich mit der Fansubbing-Szene in Zusammenhang gesetzt die Serien bereits kurz nach deren Erstausstrahlung im japanischen Fernsehen untertitelt über Filesharing verbreitet
Im Januar <num> begann TV Tokyo als erster größerer Fernsehsender seine Animes nur Stunden nach deren Ausstrahlung im japanischen Fernsehen englisch untertitelt auf einer abopflichtigen Website zu veröffentlichen Heute wird ein großer Teil der Neuerscheinungen gleichzeitig zur japanischen Ausstrahlung Simulcast auf Websites mit englischen Funimation und Crunchyroll aber auch deutschen Untertiteln gestreamt
Zusammenspiel mit anderen Medien
Die Produktion und Veröffentlichung von Animes ist oft eng mit anderen Medien verknüpft
Viele Animes beruhen auf erfolgreichen Mangas sowie vor allem in jüngerer Zeit auf Light Novels
Es wird aber auch umgekehrt nach dem Erfolg eines Animes ein entsprechender Manga gezeichnet
Vergleichsweise selten sind Anime-Comics bei denen der Manga nicht neu gezeichnet sondern aus Einzelbildern des Animes und eingefügten Sprechblasen zusammengesetzt wird
Oft ist auch die Computerspiel-Industrie an der Anime-Produktion beteiligt die auf Grundlage der Animes Computer- und Konsolenspiele produziert
Ebenfalls gab es Animes die wie
Pokémon
und
Digimon
auf erfolgreichen Spielen basieren Auch eine parallele Entwicklung oder der Beginn der Animeproduktion noch vor Start eines Spiels kommen vor
Dabei ist jedoch oft eines der Werke das Zugpferd an dessen Popularität sich die Adaption hängt
Die Zweitverwertungen werden dann vor allem von Fans und Sammlern gekauft wird die weitere Einsätze ihrer Lieblingscharaktere oder -welt erleben wollen
Unabhängig solcher Franchise- und Lizenzprodukte beeinflussten Anime und Computerspiele sich in ihren Darstellungsformen und Erzähltechniken gegenseitig
Insbesondere die Ästhetik von Manga und Anime hat den Stil von japanischen Computerspielen geprägt vor allem was das Charakterdesign betrifft
Bereits frühe japanische Computerspiele orientierten sich in der Darstellung ihrer Figuren an Manga und Anime
und Techniken wie Cel-Shading das Computeranimationen den Anschein klassischer Animationen gibt oder Prinzipien der Limited Animation werden auch in Spielen eingesetzt
Die Produktionen werden in der Regel von Produktionskomitees geleitet denen oft Unternehmen unterschiedlicher Branchen angehören so neben Buch- Spieleverlagen Studios auch Lebensmittelfirmen die Kapital einbringen und sich die Rechte am Werk aufteilen
Durch diese frühe Verknüpfung erscheinen parallel zum Anime auch Manga Romane und weitere Artikel
Teilweise werden diese Franchises dann gezielt zur Werbung für ein Produkt oder eine Produktgruppe eingesetzt
Die Zusammenarbeit in Produktionskomitees soll auch gewährleisten dass inhaltliche- und Designelemente über die einzelnen Werke hinaus im Franchise genutzt werden beispielsweise der Einsatz von Charakteren in einem Videospiel bei der Entwicklung für eine Fernsehserie schon mitgedacht wird
Dabei können jedoch Entwicklung der Geschichte der Figuren und die Darstellung von Konflikten und menschlichen Beziehungen in den Hintergrund treten Diese enge Zusammenarbeit über Komitees hat ab den <num>er Jahren deutlich zugenommen in denen auch der Medienmix an Bedeutung gewonnen hat
Praktiziert wurde diese Zusammenarbeit aber bereits seit langem so war schon
Astro Boy
<num> von Süßwaren- und Spielzeugherstellern mitfinanziert die passendes Merchandising auf den Markt brachten
Zu den diversen üblichen Merchandising-Artikel von Franchises unter anderem Artbooks Soundtrack-CDs und Klingeltöne nehmen Model-Kits und fertige Figuren eine wichtige Rolle ein
Diese werden in Japan in großer Zahl für viele Serien verkauft sind außerhalb des Landes jedoch nur schwer erhältlich Zusätzlich zu diesen Musikthemen veröffentlichen die Sprecher eines bestimmten Animes auch CDs für ihren Charakter Image Album genannt
Trotz dem Wort image beinhalten sie nur Musik undoder Textpassagen in denen der Sprecher zum Hörer spricht oder über sich singt wodurch der Zuhörer glaubt dass der Charakter selbst singt oder redet
Eine weitere Variante von Anime-CD-Veröffentlichungen sind Drama-CDs Hörspiele in denen die Sprecher eine Geschichte erzählen die häufig im Anime nicht vorkommt
Wie in Kinofilmen wird im Anime die Musik als wichtiges künstlerisches Mittel benutzt
Mit Anime-Soundtracks wird in Japan sehr viel Geld gemacht da diese sich häufig ebenso gut verkaufen wie Chartstürmer-Alben
Aus diesem Grund wird Animemusik häufig von erstklassigen Musikern komponiert und aufgeführt
Fähige Komponisten für die Hintergrundmusik sind bei den Fans hochangesehen
Zu den bekannteren Komponisten zählen z B
Joe Hisaishi Yuki Kajiura Yōko Kanno und Kenji Kawai
Am häufigsten wird Musik in Animes als Thema für einen Charakter genutzt oder um als Hintergrundmusik die Stimmung einer Szene wiederzugeben
Serien haben ein Vorspannlied als Einleitung
Dieses Thema passt für gewöhnlich zum Gesamtton der Sendung und dient dazu den Zuschauer für das anschließende Programm zu begeistern
Zwischen- und Abspannlieder kommentieren oft die Handlung oder die Sendung als Ganzes und dienen häufig dazu eine besonders wichtige Szene hervorzuheben
Diese Lieder werden häufig von bekannten Musikern oder japanischen Idolen gesungen aber auch von den Synchronsprechern Seiyū die dadurch wiederum zu Idolen werden
Somit sind sie ein sehr wichtiger Bestandteil des Programms
Gesellschaft und Politik
Während Anime genauso wie andere japanische Populärkultur noch bis in die <num>er Jahre von der Politik wenig beachtet und wenn überhaupt nur als Problem wahrgenommen wurde änderte sich dies nach <num>
Insbesondere durch Außenminister und später Premierminister Tarō Asō selbst Fan von Anime und Manga wurde ab japanische Populärkultur als wichtiger Teil der japanischen Wirtschaft und Kultur begriffen und dessen Export beworben und gefördert
Mehrere Gesetzesvorhaben stärkten den Urheberschutz und Vertreter der Anime-Industrie wurden in politische Beratungsgremien aufgenommen
Anime und Manga sollten als Soft Power beziehungsweise im Kontext mit der Idee von Cool Japan ein positives Bild Japans in der Welt vermitteln und wichtiger Teil der Exportwirtschaft sein
Diesen Initiativen entgegen steht dass Anime wie auch Manga nicht so neu und modern nicht so stilistisch und inhaltlich einheitlich sind wie die politischen Strategien sie bewerben
Stilmerkmale und Marketingstrategien haben eine weit vor <num> zurückreichende Geschichte und sind oft im Zusammenspiel mit westlichen Einflüssen entstanden sind also weniger originär japanisch als politisch suggeriert wird
Manche Animeserien werden dafür krititiert nationalistische oder revanchistische Ideen zu transportieren
Japanischen Animefans wird ein stärkeres Nationalbewusstsein zugeschrieben als anderen Teilen der Gesellschaft
Zugleich findet im Medium auch Kritik an Politik Gesellschaft und Nationalismus statt viele Werke zielen auf einheimisches Publikum und sind international nicht verständlich und die Szene und deren Vertreter versuchen sich politischer Einvernahme zu entziehen
Des Weiteren ist fraglich ob die auch in Japan recht kleine Branche die von der Politik in sie gesetzten wirtschaftlichen Hoffnungen erfüllen kann
Bekannte Anime-Studios
Eines der international bekanntesten Anime-Studios ist Studio Ghibli das seit <num> unter der Leitung von Hayao Miyazaki Filme produziert z B
Prinzessin Mononoke
<num>
Chihiros Reise ins Zauberland
<num> oder
Das wandelnde Schloss
<num>
Seinen bisher größten weltweiten Erfolg hatte Studio Ghibli mit Chihiros Reise ins Zauberland
Der Film erhielt neben zahlreichen internationalen Zuschauer- und Kritikerpreisen im Jahr <num> den Goldenen Bären auf der Berlinale und im Jahr <num> den Oscar als bester Animationsfilm was ihn zum meistausgezeichneten Zeichentrickfilm aller Zeiten macht
Bei Animeserien ist Tōei Animation bedeutend das bei frühen Science-Fiction-Klassikern wie
Uchū Senkan Yamato
auch Space Battleship Yamato und
Captain Future
und später bei
Sailor Moon
Dragon Ball
und weiteren Serien beteiligt war die große internationale Verbreitung gefunden haben
Darüber hinaus produzierte Tōei die bedeutendsten Anime-Filme der <num>er Jahre
Weitere bekannte Anime-Studios
A-<num> Pictures
Fairy Tail
Sword Art Online
Bee Train
El Cazador
hackSIGN
Madlax
Noir
Tsubasa - Reservoir Chronicle
Bones
Eureka Seven
Fullmetal Alchemist
Ouran High School Host Club
Soul Eater
Wolfs Rain
GAINAX
FLCL
Gurren Lagann
He Is My Master
Die Macht des Zaubersteins
Neon Genesis Evangelion
JCStaff
Slayers
Shakugan no Shana
To Aru Majutsu no Index
Zero no Tsukaima
Kyōto Animation
Clannad
Kanon
K-On
Lucky Star
Die Melancholie der Haruhi Suzumiya
Madhouse
Black Lagoon
Chobits
Death Note
No Game No Life
Ninja Scroll
Summer Wars
Nippon Animation Serienreihe
World Masterpiece Theater
Chibi Maruko Chan
Production IG
Blood - The Last Vampire
Ghost in the Shell
Higashi no Eden
Neon Genesis Evangelion The End of Evangelion
Jin-Roh
Shaft
Bakemonogatari
Puella Magi Madoka Magica
Magister Negi Magi Negima
Sayonara Zetsubō Sensei
Studio Pierrot
Bleach
Frau Pfeffertopf
Naruto
Saber Rider
Saiyuki
Sunrise
City Hunter
Code Geass
Cowboy Bebop
Inu Yasha
The Vision of Escaflowne
TMS Entertainment
Mila Superstar
Lupin III
Lady Oscar
Detektiv Conan
Monster Rancher
WIT Studio
Attack on Titan
Seraph of the End
Kabaneri of the Iron Fortress
Anime international
Außerhalb Asiens sind hauptsächlich die USA Frankreich und Italien für die Verbreitung von Anime in Nachbarländern wie Spanien Portugal Arabien Lateinamerika und auch Deutschland verantwortlich Die Veröffentlichung findet sowohl synchronisiert als auch untertitelt statt wobei insbesondere Fans untertitelte Fassungen oft bevorzugen um problematische Übersetzungen zu meiden
Da viele Animes Bezüge zur japanischen Kultur haben und daher für Zuschauer in anderen Ländern nicht immer leicht zugänglich sind waren außerhalb Asiens zunächst vor allem neutrale Stoffe oder solche basierend auf europäischen oder internationalen Märchen erfolgreich ehe auch stärker japanische Serien ein Publikum finden konnten Diese hatten und haben es teilweise noch immer schwer ihr Publikum zu finden da speziell japanische Stilelemente Bildsprache und Symbole außerhalb Japans für viele nicht verständlich sind
Außerdem wurden bei vielen Lokalisationen die Dialoge und teilweise auch die Handlung angepasst um sie kindgerechter zu gestalten da Zeichentrick im Westen ausschließlich als Medium für Kinderunterhaltung verstanden wurde
So wurden sexuelle Anspielungen oder Gewaltdarstellungen durch Dialogänderungen oder Schnitte entfernt oder entschärft bis hin zu sinnentstellenden Änderungen
Auch die Komplexität einiger Animes wurde durch Kürzungen reduziert oder die Musik durch neue ersetzt um die Werke dem Publikum gefälliger zu machen
USA
Anime-Serien sind im Westen erstmals in den Vereinigten Staaten im Fernsehen aufgetaucht
Dort sind in den <num>er Jahren unter anderem
Astro Boy
Kimba der weiße Löwe
Gigantor
und
Speed Racer
gelaufen
Danach waren Anime-Serien weniger präsent als es in Europa der Fall war
Die populärsten Serien waren Serien im Science-Fiction-Bereich wie
Star Blazer
Voltron
und
Robotech
In den späten <num>ern ist wie in Deutschland die internationale Vermarktung der Serien
Sailor Moon
Pokémon
und
Dragon Ball Z
für die Wahrnehmung von Anime im Speziellen verantwortlich gewesen
Auch gab es Koproduktionen zwischen den USA und Japan dazu zählen
Das Letzte Einhorn
und
Transformers
Erfolgreiche Ausstrahlungen von Anime-Serien hatten Einfluss auf die Cartoon-Industrie in den USA selbst
Serien wie
Galaxy Rangers
in den <num>ern sowie
Avatar - Der Herr der Elemente
Monsuno und
Teen Titans
in den <num>ern waren von der Anime-Ästhetik beeinflusst
Im US-Fernsehen werden für Anime die im Kinderprogramm laufen die umfangreichsten Bearbeitungsmaßnahmen unternommen
Diese Fassungen werden dann oft international vermarktet
Der amerikanische Jugendschutz ist im Vergleich zum europäischen Standard in Deutschland Frankreich etc weitaus strenger In den USA stehen den Unternehmen umfangreiche Mittel zur Verfügung um Bilder zu retuschieren Namen zu ändern Folgen auszulassen zusammenzuschneiden und somit die Handlung zu verändern
Auch die Musik wurde teilweise verändert
Freizügige gewalttätige religiöse oder japanisch-kulturelle Inhalte und auch Bezüge zu Alkohol Waffen und Drogen werden entfernt
Ernsthafte Themen wie der Tod werden umschrieben oder ausgelassen
Diese Maßnahmen unterscheiden sich von Serie zu Serie und auch von Firma zu Firma
Die konsequentesten und umfangreichsten Bearbeitungen finden bei <num>Kids
One Piece
Yu-Gi-Oh
Harmony Gold
Robotech
Saban Brands
Digimon
Glitter Force
und DiC Sailor Moon statt
Weitgehend unbearbeitete Serien haben Popularität durch Videokassetten oder durch Nachtprogramme von Sendern wie Cartoon Network oder SyFy gewonnen
Speziell im Nachtprogrammblock von Cartoon Network sind
Cowboy Bebop
und Big O sehr populär geworden
Space Dandy vom Regisseur von Cowboy Bebop
Ghost in the Shell Stand Alone Complex
und eine zweite Staffel von Big O wurde von amerikanischen Geldern mitfinanziert Netflix plant mehrere Serien mitzufinanzieren die dann als Netflix Original beworben werden
Anime in Deutschland
Als erster Anime in Deutschland wurde ab dem <num> März <num> der Film
Der Zauberer und die Banditen
von Toei Animation aus dem Jahr <num> in den Kinos gezeigt
Die erste Anime-Serie im deutschen Fernsehen war
Speed Racer
von der <num> aber nur einige Folgen gezeigt wurden ehe sie wegen Protesten abgesetzt wurde
Ähnliches geschah zu Erstausstrahlung von
Captain Future
in den <num>er Jahren
Entsprechend wurden in den <num>er und <num>er Jahren nur kinderfreundliche Serien zum Beispiel des
Masterpiece Theater
gezeigt bei denen keine Proteste zu befürchten waren
Einige davon waren deutsche Koproduktionen wie
Wickie und die starken Männer Die Biene Maja
und
Nils Holgersson
Die ersten deutschen Kauf-Animes gab es im Jahr <num> auf sogenannten TED-Bildplatten
In den <num>er Jahren erschienen zahlreiche Animes auf VHS-Kassetten
Dieser Markt war neben der Zweitverwertung von Kinderserien aus dem Fernsehen geprägt von erotischen Werken die von Trimax herausgebracht wurden Diese Importe führten dazu dass Anime noch bis nach <num> von vielen eng mit pornografischen oder stark gewalthaltigen Werken verknüpft wurden
Mit Beginn der <num>er Jahre sind im deutschen Kino häufiger Anime-Filme gezeigt worden darunter
Akira
<num>
Ghost in the Shell
<num> sowie einige Produktionen von Studio Ghibli wie
Prinzessin Mononoke
<num> und
Chihiros Reise ins Zauberland
<num>
Mit dem Aufkommen des Privatfernsehens kam auch eine Vielzahl von Anime-Serien ins Fernsehen zunächst über Einkäufe von europäischen Programmpaketem in denen neben westlichen Zeichentrickserien auch vereinzelt Anime enthalten waren
Mit der Zeit wurden auch Serien für Jugendliche ins Programm genommen und im August <num> erhielten Animes den Programmblock Moon Toon Zone bei RTL <num>
Dieser Block bestand aus
Sailor Moon Dragon Ball
und
Pokémon
und wurde mit AnimeRTL<num> ab <num> und PokitoTV im Jahr <num> ausgebaut Durch den Erfolg der RTL-<num>-Ausstrahlungen begann das bewusste Lizenzieren von Anime durch RTL<num> und andere Fernsehsender
K-Toon MTV VIVA und VOX sendeten Animes für ein älteres Publikum
Ab <num> ging dieses Angebot von Animes im Fernsehen wieder deutlich zurück
<num> wurde das Programm bei RTL II vollständig abgesetzt Von <num> bis Juni <num> gab es mit Animax Deutschland ein eigener Pay-TV-Sender für den deutschsprachigen Raum
Heute senden nur noch ProSieben MAXX seit <num> und Nickelodeon regelmäßig Animes
Die Nachbearbeitung von Animes geschah im deutschen Fernsehen und Kino lange Zeit in großem Maße und war oft Gegenstand großer Kritik von Fans
Dabei wurden zahlreiche Schnitte und inhaltliche Änderungen meist mit dem Jugendschutz begründet da Trickserien als Kinderprogramm gelten und für dieses Publikum eingekauft und gezeigt werden
Das erste deutsche Anime-Label war OVA Films gegründet <num>
Um <num> kamen immer mehr Label auf den Markt von denen sich jedoch viele nicht halten konnten
Erst ab <num> traten neue Unternehmen dazu von denen einige seit <num> auch regelmäßige Anime-Festivals veranstalten
Als erste deutsche Videoplattform startete im September <num> Kazé Deutschland das Video-on-Demand-Portal Anime on Demand Mit der Zeit folgten weitere deutsche wie internationale Angebote die jedoch nicht alle von Dauer waren
So stellte das zu ProSiebenSat<num> Media gehörende MyVideo sein <num> gestartete Angebot <num> wieder ein Seit <num> bedient das amerikanische Portal Crunchyroll auch den deutschen Markt
Eine Fanszene entwickelte sich ab den <num>er Jahren in kleinerem Maße
Mit zunehmender Verbreitung und Popularität von Animes wie auch Mangas nach der Veröffentlichung von
Akira
im Westen und umso mehr nach dem Erfolg von Fernsehserien darunter
Sailor Moon
und
Dragon Ball
entwickelte sich eine größere Fangemeinde
Diese stützte sich stark auf kommunikation über Chats und Foren es entstanden Fanzines und Veranstaltungen der Szene sowie Treffen auf Buchmessen
Darüber hinaus gehört Cosplay das Verkleiden als Figur aus einem Manga oder Anime und Fan-Art zu wichtigen Hobbys in der Szene
Außerdem findet nicht selten eine Auseinandersetzung mit japanischer Kultur und Gesellschaft jenseits von Populärkultur statt Bedeutende Veranstaltungen auf denen sich Fans vorrangig treffen sind Anime- und Manga-Conventions sowie der Japantag die Buchmessen oder Veranstaltungen zum japanischen Film
Das einzige derzeitige professionelle deutschsprachige Anime-Fachmagazin ist die
AnimaniA
die seit September <num> erscheint
Dazu kommen Jugendmagazine mit eigenen Anime-Bereichen wie Mega Hiro
Koneko
und
Kids Zone
Mittlerweile eingestellt sind die vom Verein Anime no Tomodachi herausgegebene
Funime
sowie die
MangasZene
Frankreich
In Frankreich sind Anime zum ersten Mal mit den Serien
Choppy und die Prinzessin
Erstausstrahlung folgte in Deutschland in <num> und Kimba der weiße Löwe vier Jahre vor der Deutschen Ausstrahlung im Jahr <num> aufgetaucht
Ähnlich wie bei Wickie und die starken Männer und Die Biene Maja gab es französisch-japanische Koproduktionen
Barbapapa
Odysseus <num>
und
Die geheimnisvollen Städte des Goldes
Mit der Toei-Produktion
Grendizer
auch genannt
Goldorak
wurde <num> eine Serie ausgestrahlt die maßgeblich dafür verantwortlich war dass im Kinderprogramm vermehrt auf Anime gesetzt wurde
Die Serie erreichte hohe Einschaltquoten löste aber auch große Anfeindungen und Proteste gegenüber gewalthaltigen japanischen Produktionen aus
TF<num> ist der größte Privatsender Frankreichs und setzte im Kinderprogramm stark auf Anime viele Serien waren verantwortlich für die große Fanszene in Frankreich Während RTL<num> insgesamt etwa <num> Serien zeigte waren es auf TF<num> weit über <num> AB Productions hat die Serien jedoch als billiges Kinderprogramm angesehen und diese Massen an Serien dann so im Schnitt und Dialog zusammengestutzt <num> wurde das Programm auf TF<num> nach Protesten und einen Konflikt über Anime der über <num> Jahre anhielt vollständig abgesetzt
Danach haben sich verschiedene Spartensender gefunden die ein Animeprogramm sendeten während im Kinderprogramm der großen Sender ausschließlich auf sehr kindgerechte Anime gesetzt wurde
Space Adventure Cobra gilt als der Anime mit dem höchsten Kultstatus in Frankreich Realverfilmungen und Fortsetzungen als Koproduktion sind geplant
<num> wurde
Ghost in the Shell <num> Innocence
bei den Internationalen Filmfestspielen von Cannes <num> nominiert
Wie in den USA hatten Anime Einfluss auf die heimische Zeichentrickindustrie in Frankreich
Totally Spies
und
Wakfu
sind ästhetisch an Anime angelehnt
Italien
In Italien war die Resonanz auf Anime durchwegs positiv
Seit Goldorak wurde beinahe jedes Genre und Format von Japan übernommen In Italien wurden die meisten Anime außerhalb Japans im Fernsehen und Kino gezeigt Während in Deutschland in den <num>ern und <num>ern nur knapp <num> Serien gezeigt wurden waren es in Italien bereits über <num>
Der Grund für diese Massenimporte war dass Italien bereits <num> das Fernsehen privatisierte und daraus eine Vielfalt an Sendern hervorging
Auch waren Anime die preiswertesten Zeichentrickproduktionen Koproduktionen mit Japan wie
Calimero
Z wie Zorro
und Die Abenteuer des Sherlock Holmes sind entstanden
Eine Vielzahl der Sendungen die in Kinderprogrammen der großen Sender liefen Rai und Mediaset wurden konsequent bearbeitet
So hat man Gewalt und freizügige Szenen geschnitten - aber auch Zensur und Veränderungen im Dialog wurden vorgenommen
Thematiken wie der Tod sexuelle Anspielungen japanische kulturelle Inhalte sowie drastische Bilder und Zustände wurden sehr kindgerecht und abgeflacht aufbereitet
Durch die Thematik der Serie Detektiv Conan haben sich aber solche Dialogumschreibungen wieder gelegt und diese werden inzwischen auch in anderen Serien nicht mehr verwendet
In den <num>ern <num>ern und <num>ern sind verschiedene Serien unverändert auf verschiedenen Lokalsendern gelaufen jedoch geriet
Fist of the North Star
in starke Kritik weshalb fortan auf diesen kleineren Sendern auf Anime verzichtet wurde
<num> begann mit MTV Italy die erste Ausstrahlung von Anime explizit für ein älteres Publikum zu einer passenden Sendezeit
In Italien sind speziell Anime für jüngere Mädchen beliebter als in vielen anderen Ländern speziell
Rock n Roll Kids
ist für vier Staffeln als Realserie umgesetzt worden
Der mitunter populärste Anime ist
Lupin III
Italien war Mitfinanzierer einer neuen Serie des Franchises
Lupin Sansei
Spanien
Verschiedene Animeserien sind in Spanien zunächst auf dem öffentlich-rechtlichen Sender Televisión Español gelaufen jedoch geriet
Saint Seiya
in die Kritik und wurde abgesetzt
Auch Koproduktionen wie
Um die Welt mit Willy Fog
DArtagnan und die drei MuskeTiere
und Roy the Little Cid sind entstanden
Mit dem Aufkommen des Privatfernsehens im Jahre <num> startete der Sender Telecinco
Er setzte Saint Seiya fort und importierte fast <num> weitere Animeserien
Genau wie in Frankreich und Italien hat sich die Wahrnehmung für Anime weit vor Deutschland und den USA entwickelt Jedoch kamen viele dieser Serien in die Kritik aufgrund von Gewaltdarstellungen oder auch wegen freizügigeren Szenen kurze Röcke bei Sailor Moon oder Nacktheit bei Ranma <num><num> und wurden <num> zeitweilig mit Disneycartoons ersetzt
Die zwei kulturell bedeutendsten Anime in Spanien sind
Mazinger Z
und
Shin Chan
Zu Mazinger Z gibt es eine Statue in der Stadt Tarragona und Shin Chan hatte mitunter eine größere Beliebtheit im Fernsehen als manche Hauptnachrichtensendungen
Fankultur
Japanische Animationsfilme haben weltweit eine Fangemeinde die sich in großen Teilen mit der von Mangas überschneidet
Viele Veranstaltungen widmen sich daher beiden Medien
Eine Fanszene entwickelte sich zunächst in Japan und ab den <num>er Jahren in kleinerem Maße in den USA und Frankreich
ie japanische Fanszene entstand ab den <num>er Jahren vor allem im Zusammenhang mit Science-Fiction-Serien und dem SF-Fandom
Im folgenden Jahrzehnt wurden diese Fans auch in der Anime-Industrie selbst aktiv
Die Szene emanzipierte sich von der Science-Fiction-Szene und es kam der Begriff Otaku für Anime-Fans auf der bis heute sowohl als Selbstbezeichnung als auch spöttische herabwürdigende Fremdbezeichnung verwendet wird
Ein wichtiges Porträt dieser Fans war die Kurzserie
Otaku no Video
des von Fans gegründeten Studios GainaxM it zunehmender Verbreitung und Popularität von Animes wie auch Mangas nach der Veröffentlichung von
Akira
im Westen und umso mehr nach dem Erfolg von Fernsehserien darunter
Sailor Moon
und
Dragon Ball
entwickelte sich auch in Nordamerika und Europa eine größere Fangemeinde
Als die deutsche Fanszene um das Jahr <num> herum wuchs war sie noch sehr jung
Einer Umfrage von Sozioland aus dem Jahr <num> sowie einer Untersuchung des französischen Centre dÉtudes et de Recherches Internationales zufolge waren die meisten zwischen <num> und <num> Jahren alt
Nur wenige waren über <num> spielten jedoch in der Fanszene eine wichtige Rolle gründeten die ersten Magazine und Veranstaltungen
<num> bis <num> Prozent der Befragten waren weiblich
Das Medium lädt wie auch Manga in großem Maße zu eigener Kreativität ein
In der Fanszene ist die Auseinandersetzung mit den Werken und deren Fortsetzung in Form von Dōjinshi Fan-Manga Fanfiction Fanart oder das Verkleiden als Figur aus einem Anime Cosplay weit verbreitet
Dieses große Maß an Interaktion zwischen Medium und Fans kann als ein weiteres wichtiges Merkmal von Anime gesehen werden De Anime- und Manga-Fanszene aklnn as in eine breitere Kultur moderner Japan-Mode eingebettet gesehen werden bestehend aus J-Pop und Visual Kei japanischem Essen Mode Karaoke und Computerspielen Bedeutende Veranstaltungen auf denen sich Fans vorrangig treffen sind Anime- und Manga-Conventions
Diese Conventions bieten Verkaufsstände Workshops Autogrammstunden Konzerte oder Videoabende und Cosplay-Wettbewerbe Eine der weltweit größten Conventions ist die Japan Expo in Frankreich mit über <num> Besuchern
Darüber hinaus finden viele weitere Veranstaltungen in Europa und Nordamerika statt
Daneben ist Anime auch bei Veranstaltungen zu Japan Animationsfilm Comic oder Literatur ein Thema so finden sich in Deutschland beim Japantag oder der Frankfurter Buchmesse Veranstaltungen zum japanischen Animationsfilm
Die Attraktivität des Medium für die Fans so Ralf Vollbrecht liege im deutlichen Unterschied zum westlichen Zeichentrick
Statt kindlich-kindisch zu sein würde das Körperliche und sexuelle Attraktivität stärker betont und die Geschichten seien auch bei fantastischen Stoffen in ihren Themen nah an den Lebenswelten - insbesondere Entwicklungsthemen werden oft angesprochen - und es gibt ein hohes Identifikationspotenzial für die vor allem junge Zielgruppe und Fangemeinde Auch Alexander Zahlten betont der Reiz vieler Serien gerade für jugendliches Publikum läge in der Thematisierung von Transformation des Selbst und der Begegnung mit Anderen und bringt dies in Zusammenhang mit dem Ende der bipolaren Weltordnung nach dem Ende des Kalten Krieges das eine Verunsicherung und Sorge um das Selbst gebracht habe Gerade für Mädchen biete Anime Geschichten mit besonderem Identifikationmöglichkeiten so Dinah Zank
Vor allem einige Genres von Animes sprechen in Themenwahl und Design ein weibliches Publikum an und bietet diesem auch Charaktere wie weibliche Kriegerinnen die Stereotype aufbrechen
Dabei sprechen solche Werke auch männliche Zuschauer an auch weil sie die Flucht in eine andersartige sichere fantasievolle und idealisierte Mädchenwelt bieten
Siehe auch
Liste der Anime-Titel
Liste der Anime-Vertriebe
Literatur
Gilles Poitras The Anime Companion Whats Japanese in Japanese Animation Stone Bridge Press ISBN <num>-<num>-<num>-<num> englisch <num>
Jonathan Clements Helen McCarthy The Anime Encyclopedia A Guide to Japanese Animation Since <num>
Stone Bridge Press <num> ISBN <num>-<num>-<num>-<num> englisch
Patrick Drazen Anime Explosion
- The What
Why
Wow
of Japanese Animation
Stone Bridge Press ISBN <num>-<num>-<num>-<num> englisch <num>
Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg <num> ga-netchû
Das Manga Anime Syndrom
Henschel Verlag ISBN <num>-<num>-<num>-<num>-<num>
Jonathan Clements Anime - A History
Palgrave Macmillan <num> ISBN <num>-<num>-<num>-<num>-<num>
Weblinks
Datenbanken Aniki - Größtes Wiki zum Thema Anime und Manga AIDB - Anime-Informationsdatenbank mit Releaselisten Episodenlisten und Fernsehplaner
aniSearch - Größte deutsche Anime-Informationsdatenbank mit umfangreichen Informationen
Anime News Network englisch
Teil <num> einer <num>-teiligen Reihe über ihren Einfluss auf den Westen Themen Bildsprache von Rüdiger Suchsland auf Telepolis
Einzelnachweise
Jonathan Clements Anime - A History Palgrave Macmillan <num> S <num> ISBN <num>-<num>-<num>-<num>-<num> Darin Verweis auf Ōtsuka Yasuo Sakuga Asemamire Tokuma Shoten <num> S <num> Und Tsugata Nobuyuki Nihon Hatsu no Animation Sakka Kitayama Seitarō Rinsen Shoten <num> S <num> Alexander Zahlten Something for Everyone - Anime und Politik in ga-netchû Das Manga Anime Syndrom S <num> Henschel Verlag <num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime sowie Bernd Dolle-Weinkauff Fandom Fanart Fanzine - Rezeption in Deutschland In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num> Fred Patten Whats Wrong with Japanese Animation In Watching Anime Reading Manga - <num> Years of Essays and Reviews Stone Bridge Press <num> S <num> Fred Patten Anime Versus Japanimation In Watching Anime Reading Manga - <num> Years of Essays and Reviews Stone Bridge Press <num> S <num>fClements <num> S <num>f <num>-<num> Susan J Napier Anime from Akira to Princess Mononoke Experiencing Contemporary Japanese Animation Palgrave <num> S <num>f Fred Patten Letter to the Editor Anime as Pejorative In Watching Anime Reading Manga - <num> Years of Essays and Reviews Stone Bridge Press <num> S <num>-<num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Lawrence Eng The Fans who became Kings - Gainax und die Otaku-Kultur in Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hg ga-netchû Das Manga Anime Syndrom S <num>-<num> Henschel Verlag <num> Dinah Zank Girls only - Japanische Mädchenkultur im Spiegel von Manga und Anime In ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> Das Gute im Bösen - Differnzierung statt Polarisierung In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hg ga-netchû Das Manga Anime Syndrom S <num> Henschel Verlag <num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>f <num>f ISBN <num>-<num>-<num>-<num>-<num> Thomas Lamarre Full Limited Animation in Ga-netchū - Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>f <num>f ISBN <num>-<num>-<num>-<num>-<num> Alexander Zahlten Something for Everyone - Anime und Politik in ga-netchû Das Manga Anime Syndrom S <num>-<num> Henschel Verlag <num> Julia Nieder Südwind aus Fernost - Die Filme des Studio Ghibli In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>f ISBN <num>-<num>-<num>-<num>-<num> Joachim Friedmann Sometimes Good Guys Dont wear White In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Ralf Vollbrecht Anime - Ein Phänomen aus Japan In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Joachim Friedmann Sometimes Good Guys Dont wear White In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime sowie Bernd Dolle-Weinkauff Fandom Fanart Fanzine - Rezeption in Deutschland In Deutsches Filminstitut - DIF
Deutsches Filmmuseum
Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num> <num> ff
DateiStunt Pyrotechnics Luc Viatourjpg Der Actionfilm von engl action Tat Handlung Bewegung ist ein Filmgenre des Unterhaltungskinos in welchem der Fortgang der äußeren Handlung von zumeist spektakulär inszenierten Kampf- und Gewaltszenen vorangetrieben und illustriert wird
Es geht eher um stimulierende Aktionen als um inhaltliche Zusammenhänge empathisches Miterleben der Gefühlswelt der Protagonisten oder künstlerisch-ästhetische Bildwelten
Hauptbestandteile von Actionfilmen sind daher meist aufwendig gedrehte Stunts Nahkampf-Szenen Schießereien Explosionen und Verfolgungsjagden
Geschichte
Ursprung
Der Actionfilm ist seit den <num>er-Jahren ein eigenständiges Filmgenre doch seine Konventionen sind bereits seit dem Beginn der Filmgeschichte bekannt
Künstler aus dem Vaudeville wie Buster Keaton ließen ihr Können in artistischer Bewegung in Verbindung mit Tricktechnik in ihr Filmschaffen einfließen
Der Actionfilm als eigenes Genre hat seinen Ursprung im Kriminalfilm in dem in den <num>er-Jahren Aktion und explizite Darstellung von physischer Gewalt zunehmend an Bedeutung gewann etwa in Stanley Kubricks Die Rechnung ging nicht auf
<num>
Alfred Hitchcock präsentierte in
Der unsichtbare Dritte
<num> erstmals eine geschlossene filmische Welt die ausschließlich als Herausforderung für die physische Aktion der Hauptfigur dient
Dieses Konzept der geschlossenen Actionwelt die rein zum Ausleben von Körperakrobatik und zur Demonstration spektakulärer Gewaltanwendungstechniken existiert fand seine Fortsetzung in den Filmen der James-Bond-Reihe und in Fernsehserien wie
Kobra übernehmen Sie
Dieser von realistischer Darstellung und moralischer Wertung weit entfernten Illusionstendenz stehen die Regisseure der Bewegung des New Hollywood gegenüber die in offener Form Aktion und Gewaltanwendung inszenierten
Sie reagierten auf gesellschaftliche und politische Entwicklungen wie die Protestbewegung und den Vietnamkrieg und suchten den Kontext der Darstellung zu Fragen der Moral etwa zu den Folgen von Gewaltanwendung auf den menschlichen Körper
Beispiele für diese realistischere und ernüchternde Herangehensweise sind Arthur Penns Bonnie und Clyde
<num> und Sam Peckinpahs The Wild Bunch - Sie kannten kein Gesetz
<num>
Hochphase <num>-<num>er
DateiAction film actorsjpeg Mit den Bruce-Lee-Filmen fand eine Ära der Überbetonung physischer Kräfte und des Körperkultes im Actionfilm ihren Anfang
Stilmittel wie Zeitlupe und Tonverfremdungen führten zur Entwicklung und Definition des Subgenres des Martial-Arts-Films
In den <num>er Jahren beherrschte der Actionfilm das Mainstreamkino mit Stars wie Arnold Schwarzenegger und Sylvester Stallone die durch Bodybuilding den Körperkult auf einen Höhepunkt führten
Neben wenigen humorvollen Verfilmungen wie Indiana Jones beherrschten überwiegend reaktionäre Themen wie Rachephantasien und das stereotype Aufbauen von Feindbildern das Actionkino
In den <num>er Jahren wurde das Genre zunehmend ironisiert und spiegelte sich selbst etwa in Filmen wie
Last Action Hero
John McTiernan <num> und
True Lies
James Cameron <num>
McTiernans Stirb-langsam-Reihe <num> bis <num> brach ebenfalls ironisch mit dem Heldenbild des Actionfilms und ließ ihren Protagonisten dargestellt von Bruce Willis entmystifiziert als leidensfähigen Jedermann gegen das Böse siegen
Stars wie Jackie Chan vereinnahmten den Stunt als Teil der künstlerischen Darstellung und zogen einen Teil ihrer Popularität aus der Tatsache auch gefährliche Action grundsätzlich selbst zu bewerkstelligen
Mit The Rock - Fels der Entscheidung oder Con Air wurden für das Action-Genre relativ anspruchsvolle Werke geschaffen die sich vom aufkommenden Direct-to-Video-Billigtrend abhoben
Weiterentwicklung
Zudem gewannen ab den mittleren <num>ern aufwendige digitale Spezialeffekte und Stunts gegenüber einfachen Kämpfen und Schusswechseln an Bedeutung z B
in der Mission-Impossible-Reihe mit Tom Cruise oder xXx - Triple X mit Vin Diesel
Viele Elemente des Actionfilms wurden bereits Ende der <num>er in der mit Krieg der Sterne beginnenden ersten Trilogie von Star Wars und in etwas geringerem Maße auch Star Trek in die Science Fiction übernommen
Ab <num> wurde der Superheldenfilm erneut populär welcher durch das Batman-Reboot oder Marvels Avengers die mit enormen tricktechnischen und finanziellen Mitteln produziert wurden
Spätestens in den <num>ern verschwanden klassische Actionfilme als Blockbuster weitgehend aus dem Kino und Fortsetzungen wie Stirb Langsam <num> oder dem nachempfundene Filme wie White House Down waren nur durchschnittlich erfolgreich
Eine Ausnahme stellt aber z B
die The Expendables-Trilogie dar die als Ensemble-Filme um die populären Schauspieler Schwarzenegger Stallone Willis Jason Statham Dolph Lundgren und andere als eine Art Hommage inszeniert wurde
Weibliche Protagonisten
DateiFemale action hero actressesjpg Weibliche Hauptfiguren waren bis Ende der <num>er Jahre selten eine Ausnahme stellten aber die von Sigourney Weaver verkörperte Ellen Ripley der Alien-Reihe und die von Linda Hamilton verkörperte Sarah Connor in Terminator dar
Später folgten Brigitte Nielsen Red Sonja Kate Beckinsale Underworld Uma Thurman Kill Bill Michelle Rodriguez SWAT - Die Spezialeinheit oder Halle Berry Catwoman welche meist Seite an Seite mit einem männlichen Filmpartner agierten
Mit Wonder Woman Gal Gadot oder Rogue One Felicity Jones wurden weitere Heldinnen geschaffen
Motive und Darstellungsformen
Die Bewegung Grundmotiv des Films dient im Actionfilm in erster Linie Schauzwecken und hat weniger erzählerische Funktionen
Oft werden im Actionfilm in der Art einer Nummernrevue geschlossene Sequenzeinheiten aneinandergereiht die der Zurschaustellung unterschiedlichster bewegungsgetriebener Konflikt- oder Duellsituationen dienen etwa Shootouts Verfolgungsjagden Körperkämpfe oder Explosionen
Subjekte der Aktion sind speziell im US-amerikanischen Actionfilm häufig sich verfolgende Fahrzeuge etwa in
Brennpunkt Brooklyn
William Friedkin <num>
Bullitt
Peter Yates <num> oder
Dirty Harry
Don Siegel <num>
Der dargestellten Gewalt wird häufig in wirklichkeitsfremder Weise der Realitätsbezug genommen
Filmische Mittel wie Konvergenzmontage und Parallelmontage strukturieren diese Nummern etwa um einen Spannungsbogen in einer Last-Minute-Rescue aufzulösen
In den Plots geht es meist um den Kampf zwischen Gut und Böse die Identifikationsfigur ist häufig ein physisch starker männlicher Held oder eine weibliche Heldin siehe beispielsweise
Lara Croft
derdie in der Regel eindeutige moralische Prinzipien vertritt die den ethischen und weltanschaulichen Grundlagen der westlichen Kultur entsprechen Gut gegen Böse Beschützen der Schwachen Gerechtigkeit Sühne für erlittenes Unrecht Verteidigung und Bewahrung der vertrauten Lebensweise usw Häufig fließen erzählerische Elemente aus verwandten Genres in den Actionfilm ein unter anderem aus dem Abenteuerfilm dem Kriegsfilm dem Kriminalfilm dem Psychothriller dem Horrorfilm und dem Science-Fiction-Film
Siehe auch
Liste von Actionfilmen Opferkamera
Weblinks
Schlaffe <num>er Actionhelden in der Krise - Essay <num> Seiten film-zeitde Ines Walk vom <num> Januar <num>
DateiManglehorn <num> <num>jpg Alfredo James Al Pacino
<num> April <num> in New York ist ein US-amerikanischer Schauspieler Filmregisseur und -produzent
Pacino gilt für viele Kritiker und Zuschauer als einer der herausragenden Charakterdarsteller des zeitgenössischen amerikanischen Films und Theaters
Im Laufe seiner Karriere wurde er unter anderem mit dem Oscar dem Golden Globe Award dem Tony Award und der National Medal of Arts ausgezeichnet
Eine seiner bekanntesten Rollen ist die des Michael Corleone in der von Francis Ford Coppola inszenierten Filmtrilogie Der Pate
Leben
Kindheit und Jugend
Al Pacino geboren in Manhattan ist der Sohn von Salvatore Pacino geboren in der sizilianischen Stadt Corleone und von Rose Gerard der Tochter eines italienischen Einwanderers und einer italienisch-amerikanischen Mutter die in New York geboren wurde
Seine Eltern ließen sich scheiden als er zwei Jahre alt war
Nach der Scheidung zogen Al und seine Mutter in die Bronx und Pacino wuchs bei seinen sizilianischen Großeltern die aus der Heimatstadt seines Vaters eingewandert waren in der New Yorker South Bronx auf
Sein Vater Salvatore der nach Covina zog arbeitete als Versicherungsagent und besaß ein Restaurant Pacinos Lounge Das Pacinos wurde in wirtschaftlich schweren Zeiten in den frühen <num>er Jahren geschlossen heute trägt es den Namen Citrus Grill Salvatore Pacino starb am <num> Januar <num> im Alter von <num> Jahren
Al Pacino ist der Stiefsohn der Schauspielerin und Maskenbildnerin Katherin Kovin-Pacino und hat vier Schwestern Josette eine Lehrerin die Zwillinge Roberta und Paula sowie Desiree die sein Vater in seiner vierten Ehe adoptierte
Mit <num> Jahren wurde Pacino der Schule verwiesen und ging fortan auf die Manhattan School of Performing Arts Nebenher arbeitete er in kleineren Theatern als Platzanweiser und Kartenabreißer
Schauspielkarriere
Pacino interessierte sich schon als Kind für die Schauspielerei
Er verfeinerte sein Talent an zwei renommierten New Yorker Schauspielschulen in Herbert Berghofs HB Studio und später bei Lee Strasberg im The Actors Studio
Dort spielte er in mehreren erfolgreichen Theaterstücken wie in seinem Debütstück The Connection und in The Indian Wants the Bronx für das er mit einem Obie-Award ausgezeichnet wurde
Filmschauspieler
DateiAl Pacino Cannes <num>jpg Pacino wurde durch den späteren Filmproduzenten Martin Bregman bei einem Off-Broadway-Auftritt entdeckt <num> wirkte er in seiner ersten Hollywood-Produktion Ich Natalie mit
<num> erhielt er neben Kitty Winn eine Rolle in dem Film Panik im Needle Park die ihm den Weg für die Rolle des Michael Corleone in Francis Ford Coppolas Der Pate
<num> ebnete und ihm <num> seine erste Oscar-Nominierung einbrachte
Nach
Hundstage
wurde es stiller um Pacino
Erst in den <num>er Jahren brachte er sich durch Filme wie Brian De Palmas Scarface
<num> und
Sea of Love - Melodie des Todes
<num> wieder ins Gespräch
Nach einer erneuten Zusammenarbeit mit Coppola in
Der Pate III
<num> folgte der Thriller
Heat
<num> mit Schauspielkollege Robert De Niro
Die männliche Hauptrolle in dem Film
Pretty Woman
lehnte er ab
Seine Darstellung des AIDS-kranken Schwulenhassers Roy Cohn in der Miniserie
Engel in Amerika
<num> brachte ihm zahlreiche Preise ein und wurde von der Kritik hoch gelobt
Pacino ist dafür bekannt seine Rollen bis zum Extrem auszufüllen
Während sein Spiel in den <num>er Jahren - insbesondere in der Der Pate - dabei zumeist minimalistisch und zurückhaltend war änderte es sich mit seinem Comeback in den <num>er Jahren radikal Pacinos exaltierte Darstellungen in Filmen wie Scarface Im Auftrag des Teufels An jedem verdammten Sonntag
oder auch
Der Duft der Frauen
wurden von Kritikern oftmals als Overacting bezeichnet
Für einen Großteil des Publikums zeichnet ihn allerdings genau diese Art und Weise als einen der größten Charakterdarsteller der Gegenwart aus
Viele seiner Filme darunter auch
Glengarry Glen Ross der zunächst floppte zählen heute zu den Besten ihres Genres
Theaterarbeit
Neben seiner Karriere als Filmschauspieler arbeitet er weiterhin regelmäßig an verschiedenen Theatern - sowohl als Darsteller wie auch als Regisseur und Produzent
Für seine Rollen in den Bühneninszenierungen von The Basic Training Of Pavlo Hummel von David Rabe und Does A Tiger Wear A Necktie von Don Petersen erhielt er jeweils einen Tony Award
Als langjähriges Mitglied von David Wheelers Experimental Theatre Company in Boston stand er unter anderem in
Richard III
und Bertolt Brechts Der aufhaltsame Aufstieg des Arturo Ui
auf der Bühne
In New York und London spielte Pacino in David Mamets American Buffalo in New York war er der Titelheld in
Richard III
und spielte den Mark Anton in
Julius Cäsar
Außerdem stand er im Square Theatre in New York in Oscar Wildes Salome
auf der Bühne und wirkte in der Uraufführung von Ira Levins Theaterstück Chinese Coffee mit
In der Theatersaison <num><num> spielte Pacino in der Shakespeare in the Park-Produktion
Der Kaufmann von Venedig
den Shylock
Mit der Inszenierung gewann Heather Lind die als Shylocks Tochter Jessica auftrat einen Theatre World Award für ein herausragendes Broadway-Debüt
Eigene Projekte
Pacinos erstes eigenständiges Projekt war <num> Looking for Richard eine dokumentarische und künstlerische Filmstudie über den Charakter von Shakespeares Richard III bei dem er Regie führte die Produktion übernahm das Drehbuch schrieb und die Hauptrolle spielte
Pacino war auch Produzent Hauptdarsteller und Koautor des Independent-Kurzfilms The Local Stigmatic einer Verfilmung des gleichnamigen Theaterstücks von Heathcote Williams das sowohl im New Yorker Museum of Modern Art als auch im Public Theatre aufgeführt wurde
DateiAl Pacino Roma Film Fest croppedjpg
Auszeichnungen und Ämter
Al Pacino war insgesamt acht Mal für einen Oscar nominiert
Seine erste Nominierung erhielt er <num> für seine Rolle des Michael Corleone in Der Pate von Francis Ford Coppola
Danach folgten Nominierungen für
und Gerechtigkeit für alle Der Pate - Teil II Hundstage Serpico Dick Tracy
und
Glengarry Glen Ross
<num> wurde er schließlich für seine Rolle als Lt Colonel Frank Slade in
Der Duft der Frauen
ausgezeichnet
Für seine Rolle in dem Film
Asphalt-Blüten
erhielt er <num> bei den Filmfestspielen in Cannes die Auszeichnung als bester Darsteller
Am <num> Juni <num> erhielt er im Kodak Theatre in Los Angeles den AFI Life Achievement Award des American Film Institute für sein Lebenswerk
Zusammen mit Ellen Burstyn und Harvey Keitel sitzt Pacino im Präsidium des Actors Studio
Am <num> September <num> erhielt er den Le Coultre Glory to the Filmmaker Award Der Preis ehrt bei den Filmfestspielen von Venedig alljährlich die Arbeit eines bemerkenswerten zeitgenössischen Filmschaffenden
Am <num> Februar <num> erhielt er die Goldene Kamera für sein Lebenswerk
<num> wurde er in die American Academy of Arts and Sciences gewählt
Privatleben
Al Pacino war nie verheiratet
Er hat drei Kinder eine Tochter mit Jan Tarrant und Zwillinge Tochter und Sohn
<num> mit Beverly DAngelo
Synchronstimme
Al Pacino wurde im Lauf der Jahrzehnte von verschiedenen deutschen Sprechern synchronisiert
Nachdem er im ersten Jahrzehnt seiner Karriere in der Regel von Lutz Mackensy gesprochen wurde u a
Der Pate I und II Serpico Hundstage übernahm mit Scarface <num> Frank Glaubrecht die Synchronisation des Schauspielers
Seit <num> ist Glaubrecht alleiniger Sprecher Heat City Hall Insomnia etc und er kann mittlerweile als Pacinos Standardstimme bezeichnet werden
In den frühen <num>er Jahren wurde Pacino auch von Joachim Kammer Dick Tracy Gottfried Kramer Der Pate <num> und Klaus Kindler Carlitos Way gesprochen
Filmografie
Darsteller
<num> Der Einsatz The Recruit
<num> Liebe mit Risiko - Gigli Gigli
<num> Engel in Amerika Angels in America Fernsehserie
<num> Der Kaufmann von Venedig The Merchant of Venice
<num> Das schnelle Geld Two for the Money
<num> <num> Minuten <num> Minutes
<num> Oceans <num> Oceans Thirteen
<num> Kurzer Prozess - Righteous Kill Righteous Kill
<num> Salomaybe
<num> Ein Leben für den Tod You Dont Know Jack
<num> Ein Cop mit dunkler Vergangenheit - The Son of No One
<num> Wilde Salome
<num> Jack und Jill Jack and Jill
<num> Stand Up Guys
<num> Der Fall Phil Spector Phil Spector
<num> Manglehorn
<num> Der letzte Akt The Humbling
<num> Mr Collins zweiter Frühling Danny Collins
<num> Ruf der Macht - Im Sumpf der Korruption Misconduct
<num> The Pirates of Somalia
<num> Hangman - The Killing Game Hangman
<num> Paterno Fernsehfilm
<num> Once Upon a Time in Hollywood
Regisseur
<num> Al Pacinos Looking for Richard Looking for Richard
<num> Chinese Coffee
<num> Salomaybe
<num> Wilde Salome
<num> Salomé
Produzent
<num> The Local Stigmatic Kurzfilm
<num> Al Pacinos Looking for Richard Looking for Richard
<num> The Humbling
Drehbuchautor
<num> Al Pacinos Looking for Richard Looking for Richard
<num> Wilde Salome
Auszeichnungen
Oscar
<num> Nominierung als bester Nebendarsteller Der Pate
<num> Nominierung als bester Hauptdarsteller Serpico
<num> Nominierung als bester Hauptdarsteller Der Pate - Teil II
<num> Nominierung als bester Hauptdarsteller Hundstage
<num> Nominierung als bester Hauptdarsteller und Gerechtigkeit für alle
<num> Nominierung als bester Nebendarsteller Dick Tracy
<num> Bester Hauptdarsteller Der Duft der Frauen
<num> Nominierung als bester Nebendarsteller Glengarry Glen Ross
Golden Globe Award
<num> Nominierung bester Hauptdarsteller - Drama Der Pate
<num> Bester Hauptdarsteller - Drama Serpico
<num> Nominierung als bester Hauptdarsteller - Drama Der Pate - Teil II
<num> Nominierung als bester Hauptdarsteller - Drama Hundstage
<num> Nominierung als bester Hauptdarsteller - Drama Bobby Deerfield
<num> Nominierung als bester Hauptdarsteller - Drama und Gerechtigkeit für alle
<num> Nominierung als bester Hauptdarsteller - Komödie oder Musical Daddy
Daddy
Fünf Nervensägen und ein Vater
<num> Nominierung als bester Hauptdarsteller - Drama Scarface
<num> Nominierung als bester Hauptdarsteller - Drama Sea of Love - Melodie des Todes
<num> Nominierung als bester Hauptdarsteller - Drama Der Pate - Teil III
<num> Nominierung als bester Nebendarsteller Dick Tracy
<num> Bester Hauptdarsteller - Drama Der Duft der Frauen
<num> Nominierung als bester Nebendarsteller Glengarry Glen Ross
<num> Cecil B DeMille Award für sein Lebenswerk
<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Engel in Amerika
<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Ein Leben für den Tod
<num> Nominierung als bester Hauptdarsteller - Komödie oder Musical Danny Collins
British Academy Film Award
<num> Nominierung als bester Nachwuchsdarsteller Der Pate
<num> Nominierung als bester Hauptdarsteller Serpico
<num> Bester Hauptdarsteller Hundstage
<num> Nominierung als bester Nebendarsteller Dick Tracy National Board of Review
<num> Bester Nebendarsteller Der Pate
<num> Bester Hauptdarsteller Serpico Emmy
<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Engel in Amerika
<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Ein Leben für den Tod Screen Actors Guild Awards
<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Engel in Amerika
<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Ein Leben für den Tod National Society of Film Critics
<num> Bester Hauptdarsteller Der Pate American Film Institute
<num> AFI Life Achievement Award Goldene Himbeere
<num> Nominierung als schlechtester Darsteller für Revolution
<num> Nominierung als schlechtester Nebendarsteller für Gigli
<num> Nominierung als schlechtester Darsteller für <num> Minutes und Righteous Kill
<num> Schlechtester Nebendarsteller für Jack und Jill
<num> Schlechtestes Leinwandpaar Adam Sandler und entweder Katie Holmes Al Pacino oder Adam Sandler für Jack und Jill Goldene Kamera
<num> Auszeichnung Lebenswerk international
Weblinks
- Interview mit Bruno Lester in der Frankfurter Rundschau <num> Januar <num> S <num>
- Würdigung Al Pacinos zum <num> Geburtstag in Spiegel Online <num> April <num>
Einzelnachweise
httpswwwnzzchrobert_de_niro_und_al_pacino_langweilen_sich-<num> httpswwwschwarzkopf-verlagnetstorep<num>AL_PACINOhtml httpswwwtv-mediaattop-storysal-pacino-<num>-geburtstag httpswwwmoviepilotdepeopleal-pacino httpwwwwhoswhodebioalfredo-james-pacinohtml urlhttpwwwplaybillcomnewsarticle<num>-Ellen-Barkin-Patina-Miller-John-Larroquette-Jim-Parsons-Tony-Sheldon-and-More-Win-Theatre-World-Awards
wayback<num>
textEllen Barkin Patina Miller John Larroquette Jim Parsons Tony Sheldon and More Win Theatre World Awards Playbillcom online englisch abgerufen am <num> Oktober <num> vgl Auszeichnungsliste der Biennale bei labiennaleorg abgerufen am <num> Juni <num> englisch
DateiAlkohol - Alcoholsvg DateiAlcohol generalsvg Alkohole
eigentlich feines Antimonpulver sind organische chemische Verbindungen die eine oder mehrere an unterschiedliche aliphatische Kohlenstoffatome gebundene Hydroxygruppen -O-H besitzen Der Unterschied zwischen Alkoholen und anderen Verbindungen mit OH-Gruppen z B
Enole Halbacetale oder Carbonsäuren als Teil der funktionellen Gruppe ist dass in Alkoholen jedes Kohlenstoffatom das eine OH-Gruppe trägt sp<num>-hybridisiert sein muss und außer der Hydroxygruppe nur noch an Kohlenstoff- oder Wasserstoffatomen gebunden sein darf
Nur dieser Bindungszustand entspricht dem Oxidationszustand eines normalen Alkanols
Wenn die Hydroxygruppe an ein nicht-sp<num>-hybridisiertes Kohlenstoffatom gebunden ist das Teil eines aromatischen Ringes ist so werden diese Verbindungen als Phenole bezeichnet und zählen nicht zu den Alkoholen
Während Alkohole schwächer sauer sind als Wasser und mit einem pKs-Wert von ca <num> zu den sehr schwachen Säuren zählen gehören normale Phenole mit einem pKs-Wert von <num> bereits zu den schwachen Säuren
Nomenklatur und Einteilung
Der Name einfacher Alkohole ergibt sich als Zusammensetzung aus dem Namen des ursprünglichen Alkans und der Endung
Zusätzlich wird die Position der OH-Gruppe durch eine vorangestellte Zahl verdeutlicht zum Beispiel
Eine veraltete bis <num> gültige Bezeichnung für Alkohole ist - nach einem Vorschlag von Hermann Kolbe -
Carbinole
Die Stoffgruppe der Alkohole wird nach verschiedenen Kriterien Zahl der Nichtwasserstoffnachbarn Wertigkeit Vorhandensein von Doppel-Dreifachbindungen und Kettenlänge eingeteilt
DateiPrim sec tert Alcohols V<num>png
Zahl der Nichtwasserstoffnachbarn
Man unterscheidet Alkohole nach der Zahl der C- und H-Atome an dem C-Atom der funktionellen Gruppe an das auch die Hydroxygruppe gebunden ist
Bei primären Alkoholen sind an dieses C-Atom neben einem C-Atom zwei H-Atome bei sekundären Alkoholen neben zwei C-Atomen ein H-Atom und bei tertiären Alkoholen neben drei C-Atomen kein Wasserstoffatom gebunden
Ein Sonderfall ist der Alkohol mit nur einem C-Atom das Methanol das neben der Hydroxygruppe nur drei Wasserstoffatome am C-Atom der funktionellen Gruppe trägt
Wertigkeit der Alkohole
Ist mehr als eine Hydroxygruppe an verschiedenen C-Atomen in einem Alkoholmolekül vorhanden wird deren Anzahl durch Einfügen einer der Anzahl der Hydroxygruppen entsprechenden griechischen Silbe -di- -tri- usw vor der Endung
angegeben und man spricht von mehrwertigen Alkoholen
Ein
ist das
Trivialname Ethylenglycol ein
das
Trivialname Glycerin
Die Zahl vor der Endung
gibt die Position der funktionellen Gruppen an
Dies gilt auch für einwertige Alkohole zum Beispiel
Trivialname Isopropanol
Ethanol pngStrukturformel des Ethanols<num>-propandiol numberedsvgStrukturformel <num>-propandiol numberedsvgStrukturformel
Doppel- bzw Dreifachbindungen
In Bezug auf das Vorhandensein von Doppel- bzw Dreifachbindungen in der Kette der C-Atome unterscheidet man Alkanole abgeleitet von Alkanen Alkenole abgeleitet von Alkenen und Alkinole abgeleitet von Alkinen
Für den Fall dass die OH-Gruppe an ein sp<num>-hybridisiertes Kohlenstoffatom gebunden ist hat man es mit einem anderen Oxidationszustand und damit mit einer anderen Stoffgruppe zu tun nämlich mit den meist instabilen Enolen
Allyl-alcoholpngStrukturformel des Allylalkohols <num>-Propen-<num>-ol Strukturformel von <num>-Butin-<num>-diolsvgStrukturformel des Butindiols L-Ascorbic acidsvgStrukturformel der Ascorbinsäure eines Endiols
Kettenlänge
Über die Kettenlänge werden Alkohole ebenfalls unterschieden
Die Bezeichnung
Fettalkohole
verwendet man für Alkohole mit endständiger primärer
mit gerader Kette und einer Länge von sechs Hexanol bis hin zu <num> Behenylalkohol Kohlenstoffatomen Sie werden meist durch Reduktion der
aus Fettsäuren gewonnen
Die höheren primären Alkohole mit <num> bis <num> Kohlenstoffatome bezeichnet man als Wachsalkohole
Physikalische Eigenschaften
Niedrigmolekulare Alkohole sind Flüssigkeiten die einen charakteristischen Geruch und einen brennenden Geschmack besitzen
Höhere Alkohole sind meist feste Verbindungen mit nur schwach ausgeprägtem Geruch
Aufgrund von intermolekularen Wasserstoffbrückenbindungen besitzen die Alkohole im Vergleich zu Kohlenwasserstoffen gleicher Molekülmasse relativ hohe Schmelz- und Siedepunkte Wichtigstes gemeinsames Merkmal der Alkohole ist die Hydrophilie
Diese Eigenschaft nimmt mit zunehmender Länge des Alkylrestes ab und mit der Anzahl der Hydroxygruppen zu
Besonders die kurzkettigen Alkohole werden aufgrund ihres amphiphilen Charakters oft als Lösungsmittel verwendet
Hohe Siedepunkte
DateiH-bonding alcoholsvg DateiDiagramm-Abhängigkeit des Sdp von Anzahl OH-Gruppenpng Sauerstoff ist elektronegativer als Wasserstoff und Kohlenstoff d h er zieht Elektronen stärker an als diese
Das führt zu einer unsymmetrischen Verteilung der Elektronen entlang der
man spricht von einer polaren Bindung es bildet sich ein molekularer Dipol aus
Diese Dipole können untereinander Wasserstoffbrückenbindungen ausbilden die die Anziehung der einzelnen Moleküle untereinander drastisch verstärken
Dies führt für Alkohole zu relativ hohen Siedepunkten gegenüber den um eine Methyleneinheit verlängerten Homologen ihrer Stammverbindung die eine annähernd gleiche molarer Masse besitzen
So hat beispielsweise das unpolare Ethan C<num>H<num> M
<num> einen Siedepunkt von -<num> C während Methanol CH<num>OH M
<num> diesen erst bei <num> C erreicht
Zusammenfassend
Im Vergleich zu Alkanen mit einer vergleichbaren molaren Masse haben Alkohole einen höheren Schmelz- und Siedepunkt da die Hydroxygruppe OH-Gruppe Wasserstoffbrückenbindungen ausbildet
Je mehr Hydroxygruppen ein Molekül aufweist desto mehr Wasserstoffbrückenbindungen können ausgebildet werden und desto höher ist der Siedepunkt
Zwischen den Alkylresten bilden sich zusätzlich Van-der-Waals-Kräfte aus
Deswegen steigt der Siedepunkt mit der Länge des Alkylrestes
Da die Stärke der Van-der-Waals-Wechselwirkungen nicht nur von der Größe des Alkylrestes sondern auch von dessen Oberfläche abhängig ist weisen stark verzweigte eher kugelförmige Moleküle mit einer mittelständigen Hydroxygruppe einen niedrigeren Siedepunkt als unverzweigte langgestreckte primäre Alkohole auf
Hydrophilie
Die OH-Gruppe ist ebenfalls in der Lage Wasserstoffbrückenbindungen mit Wasser einzugehen
Sie erhöht damit die Hydrophilie die Wasserlöslichkeit der Verbindung
Organische Alkylreste selbst sind nicht wasserlöslich also hydrophob
Die Wasserlöslichkeit sinkt daher mit der Größe des organischen Anteils und steigt mit der Zahl der Hydroxygruppen
Die Propanole und tert-Butanol sind bei Raumtemperatur noch in jedem Verhältnis mit Wasser mischbar alle langkettigeren Alkohole lösen sich nur noch in zunehmend kleinen Mengen
Größere Mengen gelöster anorganischer Salze können auch bei den kurzkettigen Alkoholen eine Phasentrennung bewirken Salzfracht
Zusammenfassend
Die Hydroxygruppe eines Alkohols ist aufgrund der ungleichen Ladungsverteilung polar
Somit ist die Fähigkeit derselben auch zu ebenfalls polaren Wassermolekülen Wasserstoffbrückenbindungen ausbilden zu können für die gute Löslichkeit vor allem kurzkettiger Alkohole verantwortlich
Je mehr Hydroxygruppen ein Alkohol aufweist desto mehr Wasserstoffbrücken können diese mit dem Wasser ausbilden
Daher steigt mit wachsender Anzahl der hydrophilen Hydroxygruppen die Wasserlöslichkeit
Diesem Effekt wirkt allerdings der hydrophobe also wasserabweisende unpolare Alkylrest entgegen Je länger er ist desto geringer ist die Wasserlöslichkeit des Alkohols
Acidität und Deprotonierung
Mit einem pK-Wert Säurestärke von etwa <num> sind Alkohole schwächer sauer als Wasser und reagieren somit in wässriger Lösung näherungsweise neutral
Die Acidität von Alkoholen nimmt in der Reihe von Methanol über primäre sekundäre und tertiäre Alkohole ab
Es ist möglich Alkohole mit starken Basen wie z B
Hydridanionen oder durch Reaktion mit Natrium unter Entwicklung von Wasserstoff zu deprotonieren
Die dabei entstehenden
Alkoholate
können dann als stark nucleophile Anionen für weitere Reaktionen eingesetzt werden
Es ist auch möglich Alkohole in gewissem Umfang mit starken Säuren zu protonieren DateiMethanol saeure basesvg
Spektroskopie
Im IR-Spektrum von Alkoholen ist deutlich die breite Bande der O-H-Valenzschwingung im Bereich von <num>-<num> cm-<num> zu erkennen
Die Breite des Peaks wird durch Wasserstoffbrückenbindungen mit Wassermolekülen verursacht und ist in Spektren von wasserfreien Alkoholen in einem engeren Bereich von <num>-<num> cm-<num> zu finden
Chemische Eigenschaften
Reaktion mit konzentrierter Schwefelsäure
Unterhalb von <num> C bildet sich der Ester der Schwefelsäure
Bei etwa <num> C findet die Kondensationsreaktion zu einem Ether statt
Oberhalb von <num> C werden primäre Alkohole zu Alkenen dehydratisiert
Eliminierung
Selenoxid-Eliminierung
Die Selenoxid-Eliminierung ist eine milde Variante der Eliminierung
Veresterung
Mit Carbonsäuren reagieren Alkohole unter Wasserabgabe zu Estern diese Reaktion wird auch Veresterung genannt
Diese Reaktion wird durch Säuren katalysiert
Oxidation
Primäre Alkohole lassen sich zu Aldehyden und Carbonsäuren sekundäre Alkohole zu Ketonen oxidieren
Tertiäre Alkohole lassen sich nicht weiter oxidieren es sei denn unter Zerstörung des Kohlenstoffgerüsts
Zur Oxidation von primären Alkoholen zur Carbonsäure können ChromVI-haltige Oxidationsmittel eingesetzt werden wie sie z B
bei der Jones-Oxidation Anwendung finden
Als chromfreies weniger giftiges Reagenz steht wässriges Rutheniumtetroxid zur Verfügung
Die Oxidation eines primären Alkohols kann unter Verwendung bestimmter ChromVI-Verbindungen wie dem Collins-Reagenz auch nur bis zur Stufe des Aldehyds erfolgen
Entscheidend ist dass wasserfreie Lösungsmittel eingesetzt werden
Ist kein Wasser anwesend kann keine Hydratisierung zum geminalen Diol des Aldehyds Aldehydhydrate stattfinden
ateiAlkohol - Aldehyd - Carbonsäuresvg
Da lösliche Chromate sehr giftig sind sowie karzinogene und mutagene Eigenschaften besitzen wurden alternative Methoden zur Oxidation von Alkoholen entwickelt
Eine häufig zur Anwendung kommende Methode ist die Swern-Oxidation mit aktiviertem Dimethylsulfoxid Fast alle Methoden eignen sich ebenfalls für die Oxidation sekundärer Alkohole zu Ketonen
Die folgende Aufzählung liefert eine Übersicht der wichtigsten Methoden
Oxidation zur Carbonsäurezum Keton
Jones-Oxidation ChromVI-oxid in Schwefelsäure unter Anwesenheit von Aceton
Kaliumdichromat in Schwefelsäure
Rutheniumtetroxid
Oxidation zum Aldehydzum Keton
Collins-Reagenz CrO<num>py<num> in Dichlormethan
Corey-Reagenz Pyridiniumchlorochromat PCC
Cornforth-Reagenz Pyridiniumdichromat PDC
Anelli-Oxidation kat TEMPO stöch
NaOCl
Dess-Martin-Oxidation Dess-Martin-Periodinan
Ley-Oxidation kat TPAP stöch NMO
Pfitzner-Moffatt-Oxidation DMSO DCC
Swern-Oxidation DMSO Oxalylchlorid NEt<sub><num><sub>
Acetalbildung
Mit Aldehyden reagieren Alkohole in Gegenwart saurer Katalysatoren zu Halbacetalen bzw Acetalen
Verwendung
Viele Alkohole sind wichtige Lösungsmittel die sowohl in der Industrie als auch im Haushalt eingesetzt werden die mengenmäßig wichtigsten sind Methanol Ethanol <num>-Propanol und -Butanol
Im Jahr <num> wurden weltweit etwa <num> Mio Tonnen dieser alkoholischen Lösungsmittel nachgefragt
Nachweis
Umsetzung mit metallischem Natrium
Wenn man zu einer flüssigen Alkoholprobe Natrium hinzufügt so entsteht Wasserstoff welchen man mit der Knallgasprobe nachweisen kann
Diese Methode gilt zwar als Alkoholnachweis ist jedoch nicht eindeutig da alle ausreichend protischen Substanzen zum Beispiel Carbonsäuren anorganische Säuren oder Wasser die gleiche Reaktion eingehen
Alcotest
Der Umsatz von Alkoholen mit Dichromaten in schwefelsaurer Lösung ist geeignet um Alkohole quantitativ nachzuweisen und wurde früher in den Alcotest-Röhrchen eingesetzt
Das Nachweisprinzip beruht auf dem Farbumschlag von gelb-orange saure Dichromatlösung nach grün ChromIII-Ionen und kann spektralphotometrisch gemessen werden
Certest
Eine weitere Möglichkeit besteht in der Umsetzung mit AmmoniumcerIV-nitrat
Hierbei wird eine konzentrierte Lösung von AmmoniumcerIV-nitrat mit einer verdünnten Lösung der unbekannten Substanz versetzt
Enthält die unbekannte Substanz Alkohol-Gruppen färbt sich das Gemisch rot manchmal auch grün
Enthält die Substanz Phenole fällt ein brauner Niederschlag aus
Der Grund für diese Farbreaktion ist eine Komplexbildung genauer gesagt eine Ligandensubstitution bei der ein AlkoholPhenol mit dem Sauerstoffatom am CerIV koordiniert
Durch die Veränderung der Ligandensphäre verändert sich die Farbe des CerIV von hellgelb zu rotgrünbraun
Leicht oxidierbare AlkoholePhenole können einen negativen Nachweis ergeben indem sie das CerIV zu CerIII reduzieren
Lucas-Probe
Der Nachweis des Substitutionsgrades eines Alkohols also ob es sich dabei um einen primären sekundären oder tertiären Alkohol handelt erfolgt über nucleophile Substitution der OH-Gruppe gegen Chlorid durch die Lucas-Probe
Die Substitution hat zur Folge dass sich die entstehende Substanz nicht mehr in Wasser löst und damit eine eigene Phase ausbildet
Dabei ist die Geschwindigkeit dieser Phasenbildung entscheidend
Tertiäre Alkohole reagieren bei Raumtemperatur sofort
Sekundäre Alkohole reagieren nach etwa fünf Minuten
Primäre Alkohole reagieren ausschließlich unter Erwärmen
Voraussetzung für diesen Test ist dass sich der ursprüngliche Alkohol in Wasser löst
Auch darf keine andere unter den Reaktionsbedingungen substituierbare Gruppe vorliegen
Spektroskopie und Derivatisierung
Die eindeutige Identifizierung eines unbekannten Alkohols erfolgt entweder spektroskopisch oder durch Synthese eines charakteristischen Derivates das einen Schmelzpunkt hat der von den Schmelzpunkten gleicher Derivate ähnlicher Alkohole gut zu unterscheiden ist
Oftmals werden sie über Ester der
oder der
identifiziert
Hierzu wird die zu analysierende Substanz in Gegenwart geringer Mengen Schwefelsäure umgesetzt
Die Schmelzpunkte dieser Derivate sind in der Regel scharf
Die Derivate der
besitzen in der Regel höhere Schmelzpunkte als die der
Sie werden dann bevorzugt gewählt wenn der Schmelzpunkt mit der
zu niedrig ist und keine genaue Bestimmung mehr möglich wird
Liste wichtiger Alkohole mit Schmelz- und Siedepunkten
Liste wichtiger Alkohole mit Schmelz- und Siedepunkten
omologe Reihe der einwertigen primären linearen unverzweigten AlkoholeC-AtomeMolare Masse
gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
CSiedetemperatur
CLöslichkeit
gl-<num>MethanolHolzgeist Methylalkohol -<num><num>Siegfried Hauptmann Organische Chemie <num> Auflage VEB Deutscher Verlag für Grundstoffindustrie Leipzig <num> ISBN <num>-<num>-<num>-<num> S <num>
<num>EthanolAlkohol Ethylalkohol Weingeist -<num><num> <num>
<num>Propan-<num>-oln-Propylalkohol -<num><num> <num>Butan-<num>-oln-Butylalkohol -<num><num>Pentan-<num>-oln-Amylalkohol -<num>Hans Beyer und Wolfgang Walter Organische Chemie S Hirzel Verlag Stuttgart <num> Auflage <num> S <num> ISBN <num>-<num>-<num>-<num><num>Hexan-<num>-oln-Hexylalkohol -<num><num>Hans Beyer und Wolfgang Walter Organische Chemie S Hirzel Verlag Stuttgart <num> Auflage <num> S <num> ISBN <num>-<num>-<num>-<num><num>Heptan-<num>-ol
-<num>Hans Rudolf Christensen Grundlagen der organischen Chemie Verlag Sauerländer Aarau <num> Auflage <num> S <num><num>Octan-<num>-ol
-<num><num><num>Nonan-<num>-ol
-<num> ZVG<num>CAS<num>-<num>-<num>Datum<num> April <num>-<num><num>Name<num>-NonanolDatum <num> November <num>Decan-<num>-ol <num> ZVG<num>CAS<num>-<num>-<num>Datum<num> Januar <num><num>Undecan-<num>-ol <num>Auflage<num> Titel Kapitel<num> Startseite<num> Endseite<num>Dodecan-<num>-olLaurylalkohol<num>Tridecan-<num>-ol <num>Auflage<num> Titel Kapitel<num> Startseite<num> Endseite<num>Tetradecan-<num>-olMyristylalkohol<num>-<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>Pentadecan-<num>-ol <num>Hexadecan-<num>-olCetylalkohol<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num>
<num>Octadecan-<num>-olStearylalkohol<num>-<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num>
<num>Hexacosan-<num>-olCerylalkohol<num>-<num> <num> Pa<num>
<num>Triacontan-<num>-olMyricylalkohol<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num> <num>Einwertige Alkohole sekundär und tertiär primär mit verzweigten KettenC-AtomeMolare Masse
gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
CSiedetemperatur
CLöslichkeit
gl-<num>Propan-<num>-olIsopropylalkohol Isopropanol -<num><num> <num>Butan-<num>-olSekundärer Butylalkohol -<num><num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>-Methylpropan-<num>-olIsobutylalkohol -<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>-Methylpropan-<num>-olTertiärer Butylalkohol Trimethylcarbinol<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num> <num>Pentan-<num>-olsek-n-Amylalkohol -<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>Pentan-<num>-olDiethylcarbinol -<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num> <num> C<num>-Methylbutan-<num>-ol
-<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>-Methylbutan-<num>-olIsoamylalkohol -<num><num>-Methylbutan-<num>-ol
-<num> <num>-Methylbutan-<num>-ol
<num> <num><num>-Dimethylpropan-<num>-olneo-Pentylalkohol tertiärer Amylalkohol -<num>Mehrwertige AlkoholeC-AtomeMolare Masse
gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
CSiedetemperatur
CLöslichkeit
gl-<num>Ethan-<num>-diolEthylenglycol <num>-Glycol -<num><num> <num>Propan-<num>-diolPropylenglycol -<num> <num>Propan-<num>-diolTrimethylenglycol -<num> <num>Butan-<num>-diol<num>-Butylenglycol -<num> <num>Butan-<num>-diol<num>-Butylenglycol < -<num> <num>Butan-<num>-diolTetramethylenglycol<num> <num>Butan-<num>-diol<num>-Butylenglycol<num> meso<num> meso <num>Pentan-<num>-diolPentamethylenglycol -<num> <num>Hexan-<num>-diolHexamethylenglycol<num>-<num>-<num>Octan-<num>-diolOctamethylenglycol<num>-<num>
<num>-<num> <num> hPa <num>Nonan-<num>-diolNonamethylenglycol<num>-<num>Decan-<num>-diolDecamethylenglycol<num>Propan-<num><num>-triolGlycerin Glycerol<num> Weitere AlkoholeC-AtomeMolare Masse
gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
CSiedetemperatur
CLöslichkeit
gl-<num>Cyclopentanol
-<num><num>-<num>-<num>CyclopentanolDatum<num> Juli <num> oder früher<num>Cyclohexanol <num><num><num>Prop-<num>-en-<num>-olAllylalkohol -<num> <num><num>But-<num>-en-<num>-olCrotylalkohol -<num>-Butin-<num>-ol -<num><num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>Phenylmethanol HydroxymethylbenzolBenzylalkohol -<num><num>Cyclohexylmethanol<num>-<num>-Octin-<num>-ol<num>-Octin-<num>-ol<num>-Phenylethan-<num>-ol <num>-Hydroxyethylbenzol C<num>H<num>CHOHCH<num>
α-Phenylethylalkohol<num>-Phenylethan-<num>-ol <num>-Hydroxyethylbenzol C<num>H<num>CH<num>CH<num>OH β-Phenylethylalkohol -<num>-Decanol<num>-Decanol -<num>-<num>-tert-Butylbenzylalkohol<num>-<num>Diphenylmethanol C<num>H<num><num>CHOHDiphenyltricarbinol Benzhydrol<num>Triphenylmethanol C<num>H<num><num>COHTriphenylcarbinol<num> ><num>Zum Vergleich das Phenol und Alkohole mit ähnlichen molaren MassenC-AtomeMolare Masse
gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
CSiedetemperatur
CLöslichkeit
gl-<num>PhenolCarbolsäure Benzenol
<num><num>Pentan-<num>-oln-Amylalkohol -<num><num>Hexan-<num>-oln-Hexylalkohol -<num><num>Cyclopentanol
-<num>Cyclohexanol <num><num>Anmerkung Doppelbindungenbei Siedepunkt Die Substanz zersetzt sich vor Erreichen des Siedepunktes
Werte in Klammern geben den Siedepunkt bei <num> hPa Druck an bei Löslichkeit unbegrenzt mit Wasser mischbar
Bei einzelnen Werten kann es in der Literatur zu Abweichungen kommen
Siehe auch
Alkoholpulver
Einzelnachweise
Weblinks
Schulversuche zum Thema Alkohole Brockhaus ABC Chemie VEB F A Brockhaus Verlag Leipzig <num> S <num> Science Vision Jg <num> Nr <num> März <num>
Wissenschaft-Online-Lexika Eintrag zu AlkanoleAlkohole im Lexikon der Chemie abgerufen am <num> Juli <num> Paula Yurkanis Bruice Organische Chemie Pearson Education Inc <num> <num> Auflage S <num> ISBN <num>-<num>-<num>-<num>-<num> Paula Yurkanis Bruice Organische Chemie Pearson Education Inc <num> <num> Auflage S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num>Ceresana
Markstudie Lösungsmittel
<num> Auflage UC-<num> April <num> Paula Yurkanis Bruice Organische Chemie Pearson Education Inc <num> <num> Auflage S <num> ISBN <num>-<num>-<num>-<num>-<num> NA
Aluminium im angloamerikanischen Sprachraum vielfach auch Aluminum ist ein chemisches Element mit dem Elementsymbol Al und der Ordnungszahl <num> Im Periodensystem gehört Aluminium zur dritten Hauptgruppe und zur <num> IUPAC-Gruppe der Borgruppe die früher auch als Gruppe der Erdmetalle bezeichnet wurde
Es gibt zahlreiche Aluminiumverbindungen
Aluminium ist ein silbrig-weißes Leichtmetall
In der Erdhülle ist es nach Sauerstoff und Silicium das dritthäufigste Element und in der Erdkruste das häufigste Metall
In der Werkstofftechnik werden mit Aluminium alle Werkstoffe auf Basis des Elementes Aluminium verstanden
Dazu zählt Reinaluminium mindestens <num>
Al Reinstaluminium min <num>
Al und insbesondere die Aluminiumlegierungen die Festigkeiten besitzen die mit Stahl vergleichbar sind bei nur einem Drittel seiner Dichte
Entdeckt wurde Aluminium das in der Natur fast ausschließlich in Form von chemischen Verbindungen vorkommt im frühen <num> Jahrhundert
Im frühen <num> Jahrhundert setzte die industrielle Massenproduktion ein
Die Gewinnung erfolgt in Aluminiumhütten ausgehend von dem Mineral Bauxit zunächst im Bayer-Verfahren mit dem Aluminiumoxid gewonnen wird und anschließend im Hall-Héroult-Prozess einer Schmelzflusselektrolyse bei der Aluminium gewonnen wird
<num> wurden weltweit <num> Mio Tonnen Aluminiumoxid Al<num>O<num> produziert Daraus hat man <num> Mio
Tonnen Primäraluminium gewonnen
Das Metall ist sehr unedel und reagiert an frisch angeschnittenen Stellen bei Raumtemperatur mit Luft und Wasser zu Aluminiumoxid
Dies bildet aber sofort eine dünne für Luft und Wasser undurchlässige Schicht Passivierung und schützt so das Aluminium vor Korrosion
Reines Aluminium weist eine geringe Festigkeit auf bei Legierungen ist sie deutlich höher
Die elektrische und thermische Leitfähigkeit ist hoch weshalb Aluminium für leichte Kabel und Wärmetauscher verwendet wird
Eines der bekanntesten Produkte ist Alufolie
Weitere sind Bauteile in Fahrzeugen und Maschinen elektrische Leitungen Rohre Dosen und Haushaltsgegenstände
Das Aluminiumrecycling erreicht weltweit Raten von etwa <num>
Geschichte
<num> vermutete Lavoisier als erster dass es sich bei der <num> von Marggraf aus einer Alaunlösung gewonnenen Alaunerde alumina abgeleitet von lateinisch
Alaun um das Oxid eines bislang unbekannten Elements handle
Dessen Darstellung glückte schließlich <num> dem Dänen Hans Christian Ørsted durch Reaktion von Aluminiumchlorid AlCl<num> mit Kaliumamalgam wobei Kalium als Reduktionsmittel diente
Davy der sich lange Zeit ebenfalls an der Darstellung des neuen Elements versucht hatte führte ab <num> die Namensvarianten alumium aluminum und aluminium ein von welchen die letzten beiden im Englischen bis heute nebeneinander fortbestehen
<num> gelang es Friedrich Wöhler mit der gleichen Methode wie Ørsted jedoch unter Verwendung metallischen Kaliums als Reduktionsmittel reineres Aluminium zu gewinnen
Henri Étienne Sainte-Claire Deville verfeinerte den Wöhler-Prozess im Jahr <num> und publizierte ihn <num> in einem Buch
Durch diesen verbesserten Prozess stieg die Ausbeute bei der Aluminiumgewinnung und in der Folge fiel der Preis des Aluminiums der zuvor höher als jener von Gold gewesen war innerhalb von zehn Jahren auf ein Zehntel
<num> wurde unabhängig voneinander durch Charles Martin Hall und Paul Héroult das nach ihnen benannte Elektrolyseverfahren zur Herstellung von Aluminium entwickelt der Hall-Héroult-Prozess
<num> entwickelte Carl Josef Bayer das nach ihm benannte Bayer-Verfahren zur Isolierung von reinem Aluminiumoxid aus Bauxiten
Aluminium wird noch heute nach diesem Prinzip großtechnisch hergestellt
Am Ende des <num> Jahrhunderts stand das Metall in solchem Ansehen dass man daraus gefertigte Metallschiffe auf den Namen Aluminia taufte
Vorkommen
Aluminium ist mit einem Anteil von <num> Gewichtsprozent nach Sauerstoff und Silicium das dritthäufigste Element der Erdkruste und damit das häufigste Metall
Allerdings kommt es aufgrund seines unedlen Charakters praktisch ausschließlich in gebundener Form vor
Die größte Menge befindet sich chemisch gebunden in Form von Alumosilicaten in denen es in der Kristallstruktur die Position von Silicium in Sauerstoff-Tetraedern einnimmt
Diese Silicate sind zum Beispiel Bestandteil von Ton Gneis und Granit
Seltener wird Aluminiumoxid in Form des Minerals Korund und seiner Varietäten Rubin rot und Saphir farblos verschiedenfarbig gefunden
Die Farben dieser Kristalle beruhen auf Beimengungen anderer Metalloxide
Korund hat mit fast <num> Prozent den höchsten Aluminiumanteil einer Verbindung
Einen ähnlich hohen Aluminiumanteil haben die noch selteneren Minerale Akdalait etwa <num> Prozent und Diaoyudaoit etwa <num> Prozent
Insgesamt sind bisher Stand <num> <num> aluminiumhaltige Minerale bekannt
Das einzige wirtschaftlich wichtige Ausgangsmaterial für die Aluminiumproduktion ist Bauxit
Vorkommen befinden sich in Südfrankreich Les Baux Guinea Bosnien und Herzegowina Ungarn Russland Indien Jamaika Australien Brasilien und den Vereinigten Staaten
Bauxit enthält ungefähr <num> Prozent Aluminiumhydroxid AlOH<num> und AlOOH etwa <num> Prozent Eisenoxid Fe<num>O<num> und Siliciumdioxid SiO<num>
Bei der Herstellung unterscheidet man Primäraluminium auch Hüttenaluminium genannt das aus Bauxit gewonnen wird und Sekundäraluminium aus Aluminiumschrott
Die Wiederverwertung benötigt nur etwa <num> Prozent der Energie der Primärgewinnung
Aluminium als Mineral
Infolge der Passivierung kommt Aluminium in der Natur sehr selten auch elementar gediegen vor
Erstmals entdeckt wurde Aluminium <num> durch B V Oleinikov A V Okrugin N V Leskova in Mineralproben aus der Billeekh Intrusion und dem Dyke OB-<num> in der Republik Sacha Jakutien im russischen Föderationskreis Ferner Osten
Insgesamt sind weltweit bisher rund <num> Fundorte Stand <num> für gediegen Aluminium bekannt so unter anderem in Aserbaidschan Bulgarien der Volksrepublik China Guangdong Guizhou Jiangsu und Tibet und in Venezuela
Zudem konnte gediegen Aluminium in Gesteinsproben vom Mond das die Sonde der Luna-<num>-Mission vom Krater Apollonius mitbrachte nachgewiesen werden
Aufgrund der extremen Seltenheit hat gediegen Aluminium zwar keine Bedeutung als Rohstoffquelle als gediegen vorkommendes Element ist Aluminium dennoch von der International Mineralogical Association IMA als eigenständiges Mineral anerkannt Interne Eingangs-Nr
der IMA <num>-<num>a Gemäß der Systematik der Minerale nach Strunz <num> Auflage wird Aluminium unter der System-Nummer <num>AA<num> Elemente - Metalle und intermetallische Verbindungen - Kupfer-Cupalit-Familie - Kupfergruppe eingeordnet
In der veralteten <num> Auflage der Strunzschen Mineralsystematik ist Aluminium dagegen noch nicht aufgeführt
Nur im zuletzt <num> aktualisierten Lapis-Mineralienverzeichnis das sich aus Rücksicht auf private Sammler und institutionelle Sammlungen noch an dieser Form der System-Nummerierung orientiert erhielt das Mineral die System- und Mineral-Nr
IA<num>-<num> Die vorwiegend im englischsprachigen Raum verwendete Systematik der Minerale nach Dana führt das Element-Mineral unter der System-Nr
<num><num>
In der Natur kommt gediegen Aluminium meist in Form körniger Mineral-Aggregate und Mikronuggets vor kann in seltenen Fällen aber auch tafelige Kristalle bis etwa einen Millimeter Größe entwickeln
Frische Mineralproben sind von metallisch glänzender silberweißer Farbe
An der Luft dunkeln die Oberflächen durch Oxidierung nach und wirken grau
Auf der Strichtafel hinterlässt Aluminium einen dunkelgrauen Strich
Je nach Fundort enthält Aluminium oft Fremdbeimengungen von anderen Metallen Cu Zn Sn Pb Cd Fe Sb oder tritt eingewachsen in beziehungsweise mikrokristallin verwachsen mit Hämatit Ilmenit Magnetit Moissanit und Pyrit beziehungsweise Jarosit auf
Typmaterial das heißt Mineralproben aus der Typlokalität des Minerals wird im Geologischen Museum der Akademie der Wissenschaften in Jakutsk in der russischen Teilrepublik Sacha Jakutien aufbewahrt
Gewinnung
Primäraluminium Herstellung aus Mineralien
DateiAluminium - Trend Förderungsvg
Aluminiummetall wird elektrolytisch aus einer Aluminiumoxidschmelze hergestellt
Da diese aus den auf der Erde allgegenwärtigen Alumosilicaten nur schwer isoliert werden kann erfolgt die großtechnische Gewinnung aus dem relativ seltenen silikatärmeren Bauxit
Zur Gewinnung von reinem Aluminiumoxid aus Silikaten gibt es seit langem Vorschläge deren Umsetzung allerdings bis heute nicht wirtschaftlich möglich ist
Das im Erz enthaltene Aluminiumoxid-hydroxid-Gemisch wird zunächst mit Natronlauge aufgeschlossen Bayer-Verfahren Rohrreaktor- oder Autoklaven-Aufschluss um es von Fremdbestandteilen wie Eisen- und Siliciumoxid zu befreien und wird dann überwiegend in Wirbelschichtanlagen aber auch in Drehrohröfen zu Aluminiumoxid Al<num>O<num> gebrannt
Der trockene Aufschluss Deville-Verfahren hat dagegen keine Bedeutung mehr
Dabei wurde feinstgemahlenes ungereinigtes Bauxit zusammen mit Soda und Koks in Drehrohröfen bei rund <num> C kalziniert und das entstehende Natriumaluminat anschließend mit Natronlauge gelöst
DateiSchmelzflusselektrolyse von Aluminiumsvg Die Herstellung des Metalls erfolgt in Aluminiumhütten durch Schmelzflusselektrolyse von Aluminiumoxid nach dem Kryolith-Tonerde-Verfahren Hall-Héroult-Prozess
Zur Herabsetzung des Schmelzpunktes wird das Aluminiumoxid zusammen mit Kryolith geschmolzen Eutektikum bei <num> C Bei der Elektrolyse entsteht an der den Boden des Gefäßes bildenden Kathode Aluminium und an der Anode Sauerstoff der mit dem Graphit Kohlenstoff der Anode zu Kohlenstoffdioxid und Kohlenstoffmonoxid reagiert
Die Graphitblöcke welche die Anode bilden brennen so langsam ab und werden von Zeit zu Zeit ersetzt
Die Graphitkathode Gefäßboden ist gegenüber Aluminium inert
Das sich am Boden sammelnde flüssige Aluminium wird mit einem Saugrohr abgesaugt
DateiAluwagenjpg DateiTovarna glinice in aluminija Kidričevo - kupi aluminija <num>jpg
Aufgrund der hohen Bindungsenergie durch die Dreiwertigkeit des Aluminiums ist der Prozess recht energieaufwändig
Pro produziertem Kilogramm Rohaluminium müssen <num> bis <num> Kilowattstunden an elektrischer Energie eingesetzt werden
Eine Reduzierung des Strombedarfs ist nur noch in geringem Ausmaß möglich weil die Potentiale für energetische Optimierungen weitgehend erschlossen sind Aluminiumherstellung ist daher nur in der Nähe preiswert zur Verfügung stehender Elektroenergie wirtschaftlich beispielsweise neben Wasserkraftwerken wie in Rheinfelden oder ehemals in Ranshofen unweit des Inns
Die nachfolgende Tabelle zeigt die Aluminiumproduktion und die maximal mögliche Produktionsleistung der Hüttenwerke nach Ländern
Siehe auch Liste der größten Aluminiumproduzenten
Sekundäraluminium Herstellung durch Aluminium-Recycling
Um Aluminium zu recyceln werden Aluminiumschrotte und Krätzen in Trommelöfen eingeschmolzen
Krätze ist ein Abfallprodukt bei der Verarbeitung von Aluminium und bei der Herstellung von Sekundäraluminium
Krätze ist ein Gemisch aus Aluminiummetall und feinkörnigen Oxidpartikeln und wird beim Schmelzen von Aluminium bei <num> C aus dem Aluminiumoxid der normalen Aluminiumkorrosion und als Oxidationsprodukt Oxidhaut beim Kontakt von flüssigem Aluminium mit Luftsauerstoff gebildet
Damit beim Aluminiumgießen keine Aluminiumoxidpartikel in das Gussteil gelangen wird die Krätze durch Kratzvorrichtungen von der Oberfläche des Metallbads abgeschöpft
Um die Bildung von Krätze zu verhindern wird die Oberfläche der Schmelze mit Halogenidsalzen rund zwei Drittel NaCl ein Drittel KCl und geringe Mengen Calciumfluorid CaF<num> abgedeckt siehe dazu Aluminiumrecycling
Dabei entsteht als Nebenprodukt Salzschlacke die noch ca <num> Prozent Aluminium enthält die entsprechend aufbereitet als Rohstoff für mineralische Glasfasern dient
Allerdings steht das Sekundäraluminium im Ruf dass beim Recycling pro Tonne jeweils <num> bis <num> Kilogramm Salzschlacke verunreinigt mit Dioxinen und Metallen entsteht deren mögliche Wiederverwertung aber Stand der Technik ist
Eigenschaften
Physikalische Eigenschaften
DateiAluminum Spectrajpg DateiAluminium bar surface etchedjpg DateiMacroetched AluminiumJPG
Mikrostruktur
Aluminium erstarrt ausschließlich in einem kubisch flächenzentrierten Raumgitter in der
Der Gitterparameter beträgt bei Reinaluminium <num> nm
entspricht <num> Å bei <num> Formeleinheiten pro Elementarzelle
Leerstellen kommen mit einer Dichte von <num>
<num>-<num> bei <num> C vor bei Raumtemperatur sind es nur noch <num>-<num>
Durch Abschrecken können auch größere Leerstellendichten bei Raumtemperatur vorkommen was für einige Eigenschaften von Aluminiumwerkstoffen von Bedeutung ist da die Leerstellen die Diffusion begünstigen
Durch Umformen bei Raumtemperatur kann die Leerstellendichte auf <num>-<num> erhöht werden
Die Versetzungsdichte liegt bei <num>-<num> einem für Metalle typischen Bereich und führt zur guten Umformbarkeit von Aluminium
Stapelfehler konnten bei Aluminium nicht nachgewiesen werden was mit der hohen Stapelfehlerenergie von <num> bis <num> <num>-<num> Jcm erklärt wird
Dies führt dazu dass die Festigkeitsteigerung beim Kaltwalzen und -schmieden nur gering ausfällt und manche Aluminiumwerkstoffe sogar anschließend zur Entfestigung neigen
Dichte
Mit einer Dichte von <num> gcm etwa ein Drittel von Stahl ist Aluminium ein typisches Leichtmetall was es als Werkstoff für den Leichtbau interessant macht
Die Dichte der Legierungen weicht meist nur um etwa <num>
bis -<num>
ab
Spezielle Legierungen mit Lithium haben eine <num>
geringere Dichte
Aluminium zählt somit zu den leichtesten Werkstoffen übertroffen nur noch von Magnesium
Mechanische Eigenschaften
Aluminium ist ein relativ weiches und zähes Metall
Die Zugfestigkeit von absolut reinem Aluminium liegt bei <num> Nmm die Streckgrenze bei <num> Nmm und die Bruchdehnung bei <num>
während bei handelsüblich reinem Aluminium die Zugfestigkeit bei <num> Nmm liegt die Streckgrenze bei <num> Nmm und die Bruchdehnung bei <num>
Die Zugfestigkeit seiner Legierungen liegt dagegen bei bis zu <num> Nmm Legierung <num>
Sein Elastizitätsmodul liegt bei etwa <num> GPa einem häufig angegebenen Wert
Für Reinaluminium wird ein Wert von <num> GPa angegeben
die Werte schwanken jedoch von <num> bis <num> GPa
Der G-Modul liegt bei <num> kNmm die Querkontraktionszahl Poissonzahl bei <num>
Thermische Eigenschaften
Die Schmelztemperatur liegt bei <num> C und die Siedetemperatur bei <num> C
Die Schmelztemperatur ist deutlich niedriger als die von Kupfer <num> C Gusseisen <num> C und Eisen <num> C was Aluminium zu einem guten Gusswerkstoff macht
Bei einer Sprungtemperatur von <num> K wird reines Aluminium supraleitend
Die Wärmeleitfähigkeit liegt mit <num> WK m relativ hoch
Die Wärmeleitfähigkeit von Kupfer liegt zwar etwa doppelt so hoch dafür ist die Dichte etwa viermal größer weshalb Aluminium für Wärmetauscher in Fahrzeugen genutzt wird Der Wärmeausdehnungskoeffizient ist durch den recht niedrigen Schmelzpunkt mit <num> µmm-<num>K-<num> recht hoch
Die Schwindung also die Volumenabnahme beim Erstarren liegt bei <num>
Elektrische Eigenschaften
Da thermische und elektrische Leitfähigkeit bei Metallen von denselben Mechanismen dominiert werden ist Aluminium mit
auch ein sehr guter elektrischer Leiter
In der Rangfolge der Elemente mit der größten spezifischen Leitfähigkeit steht Aluminium wie auch bei der Wärmeleitfähigkeit hinter Silber Kupfer und Gold an vierter Stelle
Durch die Kombination von hohem spezifischem Leitwert geringer Dichte hoher Verfügbarkeit und im Vergleich zu anderen Materialien geringen Kosten ist Aluminium in der Elektrotechnik - speziell in der Energietechnik wo große Leiterquerschnitte benötigt werden - neben Kupfer zum wichtigsten Leitermaterial geworden
Magnetische Eigenschaften
Aluminium ist paramagnetisch wird also von Magneten angezogen der Effekt ist jedoch sehr schwach ausgeprägt
Die Magnetische Suszeptibilität liegt bei Raumtemperatur bei <num>
<num>-<num> mkg womit Aluminium praktisch gesehen unmagnetisch ist
Chemische Eigenschaften
DateiAlkorrosionwebm Das reine Leichtmetall Aluminium hat aufgrund einer sich sehr schnell an der Luft bildenden dünnen Oxidschicht ein stumpfes silbergraues Aussehen
Diese passivierende Oxidschicht macht reines Aluminium bei pH-Werten von <num> bis <num> sehr korrosionsbeständig sie erreicht eine Dicke von etwa <num> µm
Diese Oxidschicht schützt auch vor weiterer Oxidation ist aber bei der elektrischen Kontaktierung und beim Löten hinderlich
Sie kann durch elektrische Oxidation Eloxieren oder auf chemischem Weg verstärkt werden
Die Oxidschicht kann mittels Komplexbildungsreaktionen aufgelöst werden
Einen außerordentlich stabilen und wasserlöslichen Neutralkomplex geht Aluminium in neutraler chloridischer Lösung ein
Folgende Reaktionsgleichung veranschaulicht den Vorgang
Dies geschieht vorzugsweise an Stellen wo die Oxidschicht des Aluminiums bereits geschädigt ist
Es kommt dort durch Bildung von Löchern zur Lochfraßkorrosion
Kann die chloridische Lösung dann an die freie Metalloberfläche treten so laufen andere Reaktionen ab
Aluminium-Atome können unter Komplexierung oxidiert werden
Liegen in der Lösung Ionen edlerer Metalle vor so werden sie reduziert und am Aluminium abgeschieden
Auf diesem Prinzip beruht die Reduktion von Silberionen die auf der Oberfläche von angelaufenem Silber als Silbersulfid vorliegen hin zu Silber
Aluminium reagiert heftig mit wässriger Natriumhydroxidlösung NaOH und etwas weniger heftig mit wässriger Natriumcarbonatlösung unter Bildung von Wasserstoff
Diese Reaktion wird in chemischen Rohrreinigungsmitteln ausgenutzt
Die Reaktion von Aluminium mit NaOH läuft in zwei Schritten ab der Reaktion mit Wasser und die Komplexierung des Hydroxids zu Natriumaluminat
Bei der Reaktion mit Wasser
entsteht zunächst Aluminiumhydroxid
In der Regel wird anschließend die Oberfläche getrocknet dabei wird das Hydroxid in das Oxid umgewandelt
Dies passiert jedoch nicht bei der Reaktion von Aluminium in wässriger Natronlauge
Nun folgt der <num> Schritt die Komplexierung des Hydroxids zu Natriumaluminat
Durch die Komplexierung wird das gallertartige Hydroxid wasserlöslich und kann von der Metalloberfläche abtransportiert werden
Dadurch ist die Aluminiumoberfläche nicht mehr vor dem weiteren Angriff des Wassers geschützt und Schritt <num> läuft wieder ab
Mit dieser Methode lassen sich - ebenso wie bei der Reaktion von Aluminium mit Säuren - pro zwei Mol Aluminium drei Mol Wasserstoffgas herstellen
Mit Brom reagiert Aluminium bei Zimmertemperatur unter Flammenerscheinung
Hierbei ist zu beachten dass das entstehende Aluminiumbromid mit Wasser unter Bildung von Aluminiumhydroxid und Bromwasserstoffsäure reagiert
Mit Quecksilber bildet Aluminium ein Amalgam
Wenn Quecksilber direkt mit Aluminium zusammenkommt d h wenn die Aluminiumoxidschicht an dieser Stelle mechanisch zerstört wird frisst Quecksilber Löcher in das Aluminium unter Wasser wächst dann darüber Aluminiumoxid in Gestalt eines kleinen Blumenkohls
Daher wird Quecksilber in der Luftfahrt als Gefahrgut und ätzende Flüssigkeit gegenüber Aluminiumwerkstoffen eingestuft
Auch mit Salzsäure reagiert Aluminium sehr heftig unter Wasserstoffentwicklung von Schwefelsäure wird es langsam aufgelöst
In Salpetersäure wird es passiviert
In Pulverform Partikelgröße kleiner <num> µm ist Aluminium vor allem dann wenn es nicht phlegmatisiert ist aufgrund seiner großen Oberfläche sehr reaktiv
Aluminium reagiert dann mit Wasser unter Abgabe von Wasserstoff zu Aluminiumhydroxid
Feinstes nicht phlegmatisiertes Aluminiumpulver wird auch als Pyroschliff bezeichnet
Nicht phlegmatisierter Aluminiumstaub ist sehr gefährlich und entzündet sich bei Luftkontakt explosionsartig von selbst
Isotope
In der Natur kommt ausschließlich das Isotop <num>Al vor Aluminium gehört damit zu den Reinelementen
Dieses Isotop das stabil ist und im Kern <num> Neutronen und <num> Protonen enthält absorbiert keine Neutronen weshalb Aluminium auch in Kernreaktoren genutzt wird
Alle anderen Isotope werden künstlich erzeugt und sind radioaktiv
Das stabilste dieser Isotope ist <num>Al mit einer Halbwertszeit von einer Million Jahren
Durch Elektroneneinfang oder Beta-Zerfall entsteht daraus <num>Mg durch Einfangen eines Neutrons und anschließenden Gamma-Zerfall <num>Al
Die Isotope <num>Al bis <num>Al Außer <num>Al und <num>Al haben Halbwertszeiten zwischen wenigen Sekunden und einigen hundert Sekunden
<num>Al zerfällt mit einer Halbwertszeit von nur <num> Sekunden
Aluminiumlegierungen
Aluminiumlegierungen sind Legierungen die überwiegend aus Aluminium bestehen
Für andere Legierungen die Aluminium enthalten siehe Abschnitt Weitere Anwendungen
Aluminium kann mit zahlreichen Metallen legiert werden um bestimmte Eigenschaften zu fördern oder andere ungewünschte Eigenschaften zu unterdrücken
Bei einigen Legierungen ist die Bildung der schützenden Oxidschicht Passivierung stark gestört wodurch die daraus gefertigten Bauteile teils korrosionsgefährdet sind
Nahezu alle hochfesten Aluminiumlegierungen sind von dem Problem betroffen
Es gibt Aluminiumknetlegierungen die zur Weiterverarbeitung durch Walzen Schmieden und Strangpressen gedacht sind und Gusswerkstoffe
Diese werden in Gießereien verwendet
Im Allgemeinen werden Aluminiumlegierungen in die zwei große Gruppen der Knet- und Gusslegierungen eingeteilt
Aluminiumgusslegierungen
Typische Aluminiumgusslegierungen enthalten Silicium als Hauptlegierungselement AlSi es gibt aber auch Sorten mit Kupfer oder Magnesium als Gusslegierungen
Aluminiumknetlegierungen sie haben einen Anteil von etwa <num>
und werden weiter unterteilt nach dem Hauptlegierungselementen in Reinaluminium mit Aluminiumgehalten von <num>
bis <num>
Sie sind sehr leicht zu bearbeiten haben geringe Festigkeit und gute Korrosionsbeständigkeit
Aluminium-Kupfer-Legierungen AlCu Sie haben mittlere bis hohe Festigkeit sind aushärtbar aber korrosionsanfällig und schlecht schweißbar
Sie können Zusätze von Magnesium oder Mangan enthalten
Aluminium-Mangan-Legierungen AlMn Sie haben geringe bis mittlere Festigkeit sind korrosionsbeständig und gut zu verarbeiten
Aluminium-Magnesium-Legierungen AlMg ohne AlMgSi Sie haben mittlere Festigkeiten sind nicht aushärtbar korrosionsbeständig gut umformbar und schweißbar
Die meisten Sorten enthalten zusätzlich noch Mangan AlMgMn
Aluminium-Magnesium-Silicium-Legierungen AlMgSi Sie haben mittlere bis hohe Festigkeiten sind gut zu bearbeiten durch Schweißen und Strangpressen aushärtbar und korrosionsbeständig
Aluminium-Zink-Magnesium-Legierungen AlZnMg Kupferfreie Sorten haben mittlere bis hohe Festigkeiten und sind gut schweißbar
Kupferhaltige Sorten AlZnMgCu haben hohe Festigkeiten - im Falle <num> über <num> MPa - sind nicht durch Schmelzschweißen jedoch gut durch Zerspanen Fräsen Bohren zu bearbeiten
Sonderlegierungen beispielsweise Aluminium-Lithium-Legierungen mit besonders geringer Dichte oder Automatenlegierungen die besonders gut zerspanbar sind
Außerdem wird unterschieden zwischen naturharten Legierungen - welche sich durch eine Wärmebehandlung nicht härten lassen - und aushärtbaren
Typische naturharte Aluminiumknetlegierungen sind AlMg AlMn AlMgMn AlSi
Aushärtbare Knetlegierungen - Festigkeitssteigerung durch Ausscheidungshärtung von Legierungselementen bei einer zusätzlichen Alterungsglühung bei <num> bis <num> C
Typische aushärtbare Aluminiumknetlegierungen sind AlMgSi AlCuMg AlZnMg
Die erste hochfeste aushärtbare Aluminiumlegierung AlCuMg bekam <num> die Handelsbezeichnung Duraluminium kurz Dural genannt
Wirtschaftliche Bedeutung
Aluminium ist nach Stahl der zweitwichtigste metallische Werkstoff
<num> wurden weltweit <num> Mio Tonnen produziert
DateiAl-Cu-spotpricesvg Der Aluminiumpreis bewegte sich am Weltmarkt seit <num> um den Wert von <num> Dollar pro Tonne Reinheit von <num>
Er ist jedoch relativ volatil <num> fiel er auf um die <num> Dollar pro Tonne während er <num> wieder bei annähernd <num> Dollar lag
Verwendung
Konstruktionswerkstoff allgemein
DateiAldruckgussjpg Aluminium weist eine hohe spezifische Festigkeit auf
Verglichen mit Stahl sind Bauteile aus Aluminium bei gleicher Festigkeit etwa halb so schwer weisen jedoch ein größeres Volumen auf Deshalb wird es gern im Leichtbau verwendet also dort wo es auf geringe Masse ankommt die zum Beispiel bei Transportmitteln zum geringeren Treibstoffverbrauch beiträgt vor allem in der Luft- und Raumfahrt
Auch im Kraftfahrzeugbau gewann es aus diesem Grund an Bedeutung hier standen früher der hohe Materialpreis die schlechtere Schweißbarkeit sowie die problematische Dauerbruchfestigkeit und die Verformungseigenschaften bei Unfällen geringes Energieaufnahmevermögen in der sogenannten Knautschzone im Wege
Die Haube des Washington-Denkmals ein <num> kg schweres Gussstück galt bis <num> als eines der größten Aluminiumwerkstücke Beim Bau von kleinen und mittleren Schiffen und Booten wird die Korrosionsbeständigkeit von Aluminium gegenüber Salzwasser geschätzt Der Fahrzeugbau inklusive Schiffen Flugzeugen und Schienenfahrzeugen machte <num> mit ca <num> Prozent den größten Anteil an der weltweiten Verwendung von Aluminium aus
In Aluminiumlegierungen werden Festigkeiten erreicht die denen von Stahl nur wenig nachstehen
Daher ist die Verwendung von Aluminium zur Gewichtsreduzierung überall dort angebracht wo Materialkosten eine untergeordnete Rolle spielen
Insbesondere im Flugzeugbau und in der Weltraumtechnik sind Aluminium und Duraluminium weit verbreitet
Der größte Teil der Struktur heutiger Verkehrsflugzeuge wird aus Aluminiumblechen verschiedener Stärken und Legierungen genietet
Fahrzeugbau
Bei Fahrzeugen spielt deren Masse eine Rolle Je leichter ein Fahrzeug ist desto geringer ist der Treibstoffverbrauch
In Deutschland werden knapp <num>
des Aluminiums im Fahrzeugbau verwendet Stand <num>
Autos
Bei Autos werden Aluminiumwerkstoffe verwendet für verschiedene Motorkomponenten - darunter der Motorblock die Zylinderkolben für die spezielle Kolbenlegierungen existieren die Zylinderköpfe - wo vor allem die geringe Wärmeausdehnung und Korrosionsanfäligkeit sowie die hohe Warmfestigkeit ausschlaggebend sind zusammen mit der guten Gießbarkeit da diese Komponenten üblicherweise gegossen werden
Weitere Anwendungen bei Fahrzeugen sind für Gehäuse von Getrieben als Wärmeabschirmung und als Wärmetauscher - bei den letzten beiden in Form von Reinaluminium
Im Fahrwerk wird Aluminium genutzt als Schmiedeteile für Hinterachsen Achsträger Querlenker und Räder
In der Karosserie wird Aluminium verwendet für Türen Motorhauben Stoßfänger und Kotflügel sowie in der Rohwagenstruktur
Nutzfahrzeuge
Bei Nutzfahrzeugen wird Aluminium angewandt für Bordwände Ladebordwände Aufbauten zur Ladungssicherung Druckluftbehälter Treibstofftanks und als Unterbauschutz
Der Leichtbau mit Aluminium wird bei Nutzfahrzeugen stark durch die gesetzliche Maximallast pro Achse beeinflusst Bei geringerem Fahrzeuggewicht ist eine höhere Nutzlast möglich
Schienenfahrzeuge
Auch bei Schienenfahrzeugen wird reichlich Aluminium verwendet
Voraussetzung waren dafür zwei wichtige andere Entwicklungen Bestimmte Schweißverfahren die für Aluminiumwerkstoffe geeignet sind WIG-Schweißen
MIG-Schweißen in den <num>ern und das Strangpressen von Großprofilen
Die Verwendung von Aluminium hat die gesamte Bauweise von Schienenfahrzeugen verändert
Bis etwa <num> waren Konstruktionen aus Stahlrohren üblich danach vermehrt verschweißte Profile aus Aluminium
Flugzeuge
Bereits in der Anfangsphase der Luftfahrt wurden Aluminiumwerkstoffe genutzt <num> beispielsweise Magnalium für die Beschläge eines Flugzeuges das noch größtenteils aus Holz Draht und Tuch bestand
Das erste flugfähige Ganzmetallflugzeug stammt aus dem Jahre <num> bestand allerdings aus Stahlblechen in Schalenbauweise
Die entscheidende Entwicklung zur Verwendung von Aluminium im Flugzeugbau stammt von <num> von Alfred Wilm der mit dem Duraluminium eine aushärtbare Aluminium-Kupfer-Legierung fand die sehr hohe Festigkeiten aufweist und sich daher ausgezeichnet für den Leichtbau eignet
Genutzt werden für Flugzeuge AlCu und AlZnMg
Die Gesamtmasse von Flugzeugen geht zu <num>
auf Aluminium zurück
Die Verbindung der aus Blechen gestanzten geschnittenen oder getriebenen aus dem Vollen gefrästen oder aus Profilen bestehenden Werkstücke erfolgt meist durch Nieten da die meistverwendeten Werkstoffe schlecht schweißbar sind
Elektrotechnik
Elektrische Leitungen
DateiKurzschlussljpg Aluminium ist ein guter elektrischer Leiter
Es weist nach Silber Kupfer und Gold die vierthöchste elektrische Leitfähigkeit aller Metalle auf
Ein Leiter aus Aluminium hat bei gegebenem elektrischen Widerstand eine kleinere Masse aber ein größeres Volumen als ein Leiter aus Kupfer
Daher wird meistens dann Kupfer als elektrischer Leiter verwendet wenn das Volumen eine dominante Rolle spielt wie beispielsweise bei den Wicklungen in Transformatoren
Aluminium hat dann als elektrischer Leiter Vorteile wenn das Gewicht eine wesentliche Rolle spielt beispielsweise bei den Leiterseilen von Freileitungen Aus dem Grund der Gewichtsreduktion werden auch in Flugzeugen wie dem Airbus A<num> Aluminiumkabel verwendet
Aluminium wird unter anderem auch zu Stromschienen in Umspannwerken und zu stromführenden Gussteilen verarbeitet
Für Elektroinstallationen gibt es kupferkaschierte Aluminiumkabel der Kupferüberzug ist zur Verbesserung der Kontaktgabe
In diesem Anwendungsbereichen sind primär Rohstoffpreise entscheidend da Aluminium preisgünstiger als Kupfer ist
Für Oberleitungen bei elektrischen Bahnen ist es dagegen aufgrund seiner schlechten Kontakt- und Gleiteigenschaften ungeeignet in diesem Bereich wird trotz des höheren Gewichts primär Kupfer eingesetzt
Beim Kontaktieren unter Druck ist Aluminium problematisch da es zum Kriechen neigt
Außerdem überzieht es sich an Luft mit einer Oxidschicht
Nach längerer Lagerung oder Kontakt mit Wasser ist diese isolierende Schicht so dick dass sie vor der Kontaktierung beseitigt werden muss
Vor allem im Kontakt mit Kupfer kommt es zu Bimetallkorrosion
Bei ungeeigneten Kontaktierungen in Klemmen kann es bei Aluminiumleitern in Folge zu Ausfällen und Kabelbränden aufgrund sich lösender Kontakte kommen
Crimpverbindungen mit passenden Hülsen und Werkzeugen sind jedoch sicher
Als Zwischenlage zwischen Kupfer und Aluminium können Verbindungsstücke aus Cupal die Kontaktprobleme vermeiden
Hervorzuheben ist das geringe Absinken der spezifischen elektrischen Leitfähigkeit von Aluminium bei Zusatz von Legierungsbestandteilen wohingegen Kupfer bei Verunreinigungen eine deutliche Verringerung der Leitfähigkeit zeigt
Elektronik
DateiTransistoroffenjpg Die Elektronikindustrie setzt Aluminium aufgrund der guten Verarbeitbarkeit und der guten elektrischen und Wärme-Leitfähigkeit ein
In integrierten Schaltkreisen wurde bis in die <num>er-Jahre ausschließlich Aluminium als Leiterbahnmaterial eingesetzt
Bis in die <num>er-Jahre wurde es auch als Material für die Steuerelektrode Gate von Feldeffekttransistoren mit Metall-Isolator-Halbleiter-Struktur MOSFET beziehungsweise MOS-FET verwendet Neben dem geringen spezifischen Widerstand sind für die Verwendung die gute Haftung auf und geringe Diffusion in Siliciumoxiden Isolationsmaterial zwischen den Leiterbahnen sowie die einfache Strukturierbarkeit mithilfe von Trockenätzen ausschlaggebend
Seit Anfang der <num>er-Jahre wird Aluminium jedoch zunehmend durch Kupfer als Leiterbahnmaterial ersetzt auch wenn dafür aufwendigere Strukturierungsverfahren vgl Damascene- und Dual-Damascene-Prozess und Diffusionsbarrieren notwendig sind Der höheren Fertigungsaufwand wird durch den geringeren spezifischen Widerstand der im Fall von kleinen Strukturen bei Aluminium viel früher signifikant ansteigt und anderen Eigenschaften z B
Elektromigrationverhalten überwogen und die Aluminium-Prozesse konnte die gestiegenen Anforderungen Taktfrequenz Verlustleistung etc in mit hohen Frequenzen arbeitenden Schaltkreisen nicht mehr genügen siehe auch RC-Glied
Aluminium wird jedoch weiterhin auch in mikroelektronischen Produkten verwendet so wird es wegen seiner guten Kontaktierbarkeit durch andere Metalle in den letzten Leiterbahnebenen eingesetzt um den elektrischen Kontakt zu den bei der Flip-Chip-Montage eingesetzten Lotkügelchen herzustellen
Ähnlich verhält es sich bei Leistungshalbleitern bei denen in der Regel alle Leiterbahnebenen aus Aluminium bestehen
Allgemein und insbesondere bei Leistungshalbleitern wird das Material für Bonddrähte Verbindungsdrähte zwischen Chip und Gehäuseanschluss verwendet
Mit der Einführung der High-kMetal-Gate-Technik hat Aluminium nach gut <num> Jahren Abstinenz auch im Bereich des Gates an Bedeutung gewonnen und wird neben anderen als Material zur Einstellung der Austrittsarbeit eingesetzt
Verpackung und Behälter
DateiMoka<num>jpg
In der Verpackungsindustrie wird Aluminium zu Getränke- und Konservendosen sowie zu Aluminiumfolie verarbeitet
Dabei macht man sich die Eigenschaft der absoluten Barrierewirkung gegenüber Sauerstoff Licht und anderen Umwelteinflüssen zunutze
Ausschlaggebend für die Verwendung von Aluminium als Verpackung ist nicht die geringe Dichte sondern die gute Verarbeitbarkeit durch Walzen und die Ungiftigkeit Dünne Folien werden in Stärken von sechs Mikrometern hergestellt und dann zumeist in Verbundsystemen eingesetzt beispielsweise in Tetra Paks
Kunststofffolien können durch Bedampfen mit Aluminium mit einer dünnen Schicht versehen werden welche dann eine hohe aber nicht vollständige Barrierefunktion aufweist
Grund dieser Barrierewirkung ist nicht das reine Aluminium sondern die Passivschicht aus Böhmit
Wird diese verletzt so kann Gas ungehindert durch den Werkstoff Aluminium strömen
Genutzt werden meist Reinaluminium AlMn Legierungen mit Mangan und AlMg Legierungen mit Magnesium
Aus Aluminium werden auch Kochtöpfe und andere Küchengeräte wie die klassische italienische Espressokanne sowie Reise- und Militär-Geschirr hergestellt
Aluminium wird für eine Vielzahl von Behältern und Gehäusen verarbeitet da es sich gut durch Umformen bearbeiten lässt
Gegenstände aus Aluminium werden häufig durch eine Eloxalschicht vor Oxidation und Abrieb geschützt
<num> entfielen <num>
der europäischen Aluminiumverwendung auf Verpackungen
Tolkki<num>jpgGetränkedose
Optik und Lichttechnik
DateiImage-Metal-reflectancepng Aluminium wird aufgrund seines hohen Reflexionsgrades als Spiegelbeschichtung von Oberflächenspiegeln unter anderem in Scannern Kraftfahrzeug-Scheinwerfern und Spiegelreflexkameras aber auch in der Infrarotmesstechnik eingesetzt
Es reflektiert im Gegensatz zu Silber auch Ultraviolettstrahlung
Aluminium-Spiegelschichten werden meist durch eine Schutzschicht vor Korrosion und Kratzern geschützt
Architektur und Bauwesen
Betonherstellung
Aluminiumpulver und Aluminiumpasten werden zur Herstellung von Porenbeton eingesetzt Man verwendet Verbindungen wie Aluminiumhydroxysulfat Aluminiumdihydroxyformiat oder amorphes Aluminiumhydroxid als alkalifreie Spritzbetonbeschleuniger
Konstruktions- und Funktionswerkstoffe
Aluminium wird als Konstruktionswerkstoff für tragende Teile von Bauwerken und als Funktionswerkstoff als dekorative korrisionsbeständige Teile verwendet
Neben der Witterungsbeständigkeit ist vor allem die gute Verarbeitbarkeit ausschlaggebend insbesondere bei handwerklicher Fertigung
Das Baugewerbe ist der Hauptabnehmer für Aluminiumprofile
Genutzt wird Aluminium hauptsächlich für Fensterrahmen Türen und Elemente von Fassaden
Besonders bekannt ist die Fassade des Imperial War Museums in Manchester
Genutzt werden vor allem die Aluminium-Mangan-Legierungen die geringe Festigkeit und gute Korrosionsbeständigkeit haben
Teilweise wird Aluminium auch für den Brückenbau angewandt wo sonst der Stahlbau vorherrscht
Für den konstruktiven Ingenieurbau werden Legierungen mit höherer Festigkeit genutzt darunter AlMg und AlSi Bleche und Verbundplatten aus Aluminiumlegierungen erreichen Brandschutzklassen von nicht brennbar bis normal entflammbar Ein Wohnungsbrand entwickelt im Vollbrand <num> C Hitze was ungeachtet der Brandschutzklasse Löcher in die Aluminiumlegierung brennt die zwischen <num> C und <num> C nach unten fließt oder tropft
Imperial War Museum <num>croppedjpgDas Imperial War Museum von AußenLibeskindSpaceFrameTowerjpgDachkonstruktion aus Aluminium beim Imperial War MuseumAluminium heat reflector with hole melted through by high temperaturesjpgAluminiumblech punktuell über <num> C erhitzt
Weitere Anwendungen
In der Raketentechnik besteht der Treibstoff von Feststoffraketen zu maximal <num> Prozent aus Aluminiumpulver das bei seiner Verbrennung viel Energie freisetzt Aluminium wird in Feuerwerken s a
Pyrotechnik verwendet wo es je nach Körnung und Mischung für farbige Effekte sorgt
Auch in Knallsätzen findet es oft Verwendung
Bei der Aluminothermie wird Aluminium zur Gewinnung anderer Metalle und Halbmetalle verwendet indem das Aluminium zur Reduktion der Oxide genutzt wird
Ein wichtiges Verfahren der Aluminothermie ist die Thermitreaktion bei der Aluminium mit EisenIII-oxid umgesetzt wird
Bei dieser stark exothermen Reaktion entstehen Temperaturen bis zu <num> C und flüssiges Eisen das zum aluminothermischen Schweißen genutzt wird z B
zum Fügen von Bahngleisen
Weitere Anwendungen der Reduktionswirkung von Aluminium werden für Laborzwecke ermöglicht indem Aluminiumamalgam verwendet wird
Aluminium dient als Pigment für Farben Silber- oder Goldbronze
Farbig eloxiert ist es Bestandteil vieler Dekorationsmaterialien wie Flitter Geschenkbänder und Lametta
Zur Beschichtung von Oberflächen wird es beim Aluminieren verwendet
Mit Aluminium werden Heizelemente von Bügeleisen und Kaffeemaschinen umpresst
Bevor es gelang Zinkblech durch Titanzusatz als so genanntes Titanzink verarbeitbar zu machen wurde Aluminiumblech für Fassaden- und Dachelemente siehe Leichtdach sowie Dachrinnen eingesetzt
Wegen seiner hohen Wärmeleitfähigkeit wird Aluminium als Werkstoff für stranggepresste Kühlkörper und wärmeableitende Grundplatten verwendet
Aluminium-Elektrolytkondensatoren verbauen Aluminium als Elektrodenmaterial und Gehäusewerkstoff weiters wird es zur Herstellung von Antennen und Hohlleitern verwendet
Aluminium kommt in einigen Legierungen vor
Neben den Aluminiumlegierungen die überwiegend aus Aluminium bestehen kommt es noch vor in den Kupferlegierungen Aluminiumbronze Aluminiummessing Isabellin zu etwa gleichen Teilen Al und Kupfer in der Devardaschen Legierung als Hauptlegierungselement für Magnesiumlegierungen sowie in Alnico und Sendust zwei Eisenlegierungen mit besonderen magnetischen Eigenschaften
In vielen Titanlegierungen kommt ebenfalls Aluminium vor insbesondere in Ti-<num>Al-<num>V der Sorte die etwa <num>
aller Titanlegierungen ausmacht Dort ist Aluminium mit <num> Massenprozent enthalten
Verarbeitung
Bei der Verarbeitung wird unterschieden ob es sich um Gusslegierungen handelt oder um Knetlegierungen
Gusslegierungen werden in Gießereien verarbeitet und in Formen gegossen die schon vollständig oder weitgehend der Form der Endprodukte entsprechen
Danach erfolgt eine Endbearbeitung durch Schleifen
Gusslegierungen werden häufig aus Schrott erschmolzen
Knetlegierungen werden in den Hüttenwerken zu Barren vergossen und anschließend dort gewalzt um Platten Bleche Stangen und Folien herzustellen
Aus dicken Platten und anderen massiven Rohteilen werden durch Zerspanen Fräsen Bohren und Drehen Einzelteile hergestellt
Andere massive Rohteile können durch Schmieden zu Einzelstücken verarbeitet werden oder durch Strangpressen zu Profilen
Letzteres kommt bei Aluminium besonders häufig vor
Bleche werden durch Stanzen Biegen und Tiefziehen verarbeitet
Danach werden die Einzelteile durch Schweißen Nieten Löten und ähnliche Verfahren verbunden
Gießen
DateiMaterialprobe BBSjpg DateiDatenschieber für den Aluminium Gussjpg
Das Gießen von Aluminium wird als Aluminiumguss bezeichnet
Es gehört aufgrund seines vergleichsweise geringen Schmelzpunktes von <num> C Gusseisen etwa <num> C Stahl <num> C bis <num> C und seiner guten Gießbarkeit zu den häufig in der Gießerei verwendeten Werkstoffen
AlSi spezielle Gusslegierungen mit Silicium haben sogar Schmelzpunkte um <num> C Der Massenanteil von Aluminium aller in Gießereien erzeugten Produkte beträgt etwa <num>
Gusseisen <num>
Stahlguss <num>
und ist damit in der Gießerei das mit Abstand wichtigste Nichteisenmetall NE-Metalle noch vor Kupfer mit <num>
Der Anteil am NE-Metallguss von Aluminium beträgt etwa <num>
In Deutschland wurden <num> etwa <num> Tonnen Aluminium in Gießereien verarbeitet Etwa <num>
des Nichteisenmetall-Gusses wird von der Automobilbranche abgenommen
Aus dem niedrigen Schmelzpunkt folgt ein geringer Energieeinsatz beim Schmelzvorgang sowie eine geringere Temperaturbelastung der Formen Aluminium eignet sich grundsätzlich für alle Gussverfahren insbesondere für Druckguss beziehungsweise Aluminiumdruckguss mit denen auch kompliziert geformte Teile gefertigt werden können
In der Gießerei werden besondere Aluminiumgusslegierungen verarbeitet größtenteils die Aluminium-Silicium-Legierungen
In den Hüttenwerken werden dagegen meist Knetlegierungen erzeugt die zur Weiterbearbeitung durch Walzen Schmieden und Fließpressen gedacht sind
Diese werden in den Hüttenwerken vergossen zu Barren Blockguss oder zu Rundbarren die theoretisch endlos sein können Strangguss
Seit den <num>er-Jahren kommt der Strangguss vermehrt zum Einsatz
Dafür gibt es spezielle Anlagen die bis zu <num> Rundbarren gleichzeitig herstellen können mit Gießlängen zwischen <num> und <num> Metern teils bis zu <num> Metern
Die Durchmesser liegen bei <num> bis <num> mm
Bleche werden manchmal hergestellt durch Gießen direkt auf eine Walze die die Schmelze kühlt
Das Rohblech wird danach direkt kaltgewalzt ohne Warmwalzen was Kosten von bis zu <num>
spart
Umformende Verfahren
Etwa <num> Prozent des Aluminiums wird durch Umformen bearbeitet Hierzu zählt unter anderem das Walzen Schmieden Strangpressen und Biegen
Rein- und Reinstaluminium lässt sich wegen der niedrigen Festigkeit gut umformen und verfestigt sich bei Kaltumformung wobei große Formänderungen möglich sind
Die Verfestigung lässt sich durch Rekristallisationsglühen beseitigen
Knetlegierungen mit AlMg und AlMn erreichen ihre höhere Festigkeit durch die Legierungselemente und durch Kaltverformung
Die aushärtbaren Legierungen AlMgSi AlZnMg AlCuMg und AlZnMgCu scheiden bei Umformung festigkeitssteigernde Phasen aus sie lassen sich relativ schwierig umformen
Walzen
Gegossene Barren werden häufig durch Walzen weiterverarbeitet entweder zu dicken Platten die anschließend durch Fräsen zu Endprodukten werden zu Blechen die durch Stanzen und Biegen weiterverarbeitet werden oder zu Folien
Beim Walzen ändert sich die Mikrostruktur der Werkstoffe Kleine kugelförmige Bestandteile die häufig nach dem Gießen vorliegen werden plattgedrückt und in die Länge gezogen
Das Gefüge wird dadurch einerseits feiner und gleichmäßiger andererseits aber auch Richtungsabhängig
Die Kapazität einer Aluminium-Warmwalzanlage liegt bei etwa <num> Tonnen pro Jahr
Verarbeitet werden Barren mit bis zu <num> Tonnen Masse
Sie haben Abmessungen von bis zu <num> Metern Länge <num> Metern Breite und <num> cm Dicke
Noch größere Barren können technisch verarbeitet werden die Gefügequalität nimmt dann aber ab
Nach dem Warmwalzen liegt der Werkstoff meist mit Dicken von etwa <num> bis <num> mm vor
Anschließend folgt das Kaltwalzen auf Enddicke
Kaltwalzwerke haben Kapazitäten von <num> bis <num> Jahrestonnen
Verbundwerkstoffe können durch Walzplattieren hergestellt werden
Dabei wird ein- oder zweiseitig eine Schicht aus einem anderen Werkstoff aufgebracht
Häufig wird auf korrosionsanfälliges Kernmaterial eine Schicht aus korrosionsbeständigem Reinaluminium aufgebracht
Strangpressen
DateiExtruded aluminium section x<num>jpg Aluminium lässt sich durch Strangpressen in komplizierte Konstruktionsprofile formen hierin liegt ein großer Vorteil bei der Fertigung von Hohlprofilen z B
für Fensterrahmen Stäbe Balken Kühlkörperprofilen oder in der Antennentechnik
Die Herstellung von Halbzeug oder Bauteilen geschieht aus Vormaterial wie etwa Walzbarren Blech oder Zylindern
Aluminiumlegierungen lassen sich deutlich besser strangpressen als andere Werkstoffe weshalb ein großer Teil des Aluminiums mit diesem Verfahren verarbeitet wird
Dabei wird das Ausgangsmaterial durch ein hohles Werkzeug gepresst
Es entsteht Endlosmaterial das in der gewünschten Länge abgesägt wird
Es können auch komplizierte Querschnitte hergestellt werden beispielsweise Hohlprofile oder welche mit Hinterschneidungen
Der Querschnitt ist allerdings über die Länge konstant
Mit hochfesten Legierungen sind große Mindestwanddicken erforderlich und das Pressen dauert lange weshalb eher die mittelfesten aushärtbaren Legierungen bevorzugt werden
Die Aushärtung wird meist direkt im Anschluss durchgeführt
Beim Strangpressen wird der Werkstoff auf Temperaturen von etwa <num> bis <num> C erwärmt um die Umformbarkeit zu erhöhen was gleichzeitig zum Lösungsglühen genutzt wird
Direkt nach dem Strangpressen wird das Werkstück durch Luft oder Wasser starkt abgekühlt und so abgeschreckt was zu höheren Festigkeiten führt
Sonstige
Ein Mischverfahren aus Gießen und Schmieden ist Cobapress welches speziell für Aluminium ausgelegt ist und häufig in der Automobilbranche genutzt wird
Moderne Walzwerke sind sehr teuer aber auch sehr produktiv
Spanende Verfahren
DateiSchruppenDrehenjpg
Zum Zerspanen zählt das Drehen Bohren und Fräsen
Aluminiumwerkstoffe sind gut spanbar Ihre genauen Eigenschaften hängen jedoch von der Legierung und Gefügezustand ab
Zu beachten ist dass die bei der Bearbeitung auftretenden Temperaturen schnell im Bereich des Schmelzpunktes liegen können
Bei gleichen Schnittparametern wie bei Stahl resultiert bei Aluminium allerdings eine geringere mechanische und thermische Belastung
Als Schneidstoff wird oft Hartmetall für untereutektische oder Diamant für die stark verschleißenden übereutektischen Legierungen verwendet Insbesondere die Bearbeitung von eloxierten Werkstücken erfordert harte Werkzeuge um Verschleiß durch die harte Eloxalschicht zu vermeiden
Die beim Schleifen von Aluminium entstehenden Schleifstäube können zu einem erhöhten Explosionsrisiko führen
Schweißen und Löten
Grundsätzlich sind alle Aluminium-Werkstoffe zum Schweißen geeignet wobei jedoch reines Aluminium zu Poren in der Schweißnaht neigt Außerdem neigt die Aluminiumschmelze zu Reaktionen mit der Atmosphäre weshalb fast immer unter Schutzgas geschweißt wird
Gut geeignet sind das MIG- und Plasmaschweißen sowie das WIG-Schweißen
Bei Letzterem wird bei Nutzung von Wechselstrom das Edelgas Argon als Schutzgas verwendet und bei Gleichstrom Helium
Für das Laserschweißen eignen sich sowohl Kohlendioxid- als auch Festkörperlaser allerdings nicht für alle Legierungen
Wegen der hohen Wärmeleitfähigkeit erstarrt die Schmelze sehr schnell sodass die Schweißnaht zu Poren und Rissen neigt
Das Widerstandspunktschweißen erfordert verglichen mit Stahl höhere elektrische Ströme und kürzere Schweißzeiten sowie teilweise spezielle Geräte da die handelsüblichen Schweissgeräte für Stahl nicht dafür geeignet sind
Für das Elektronenstrahlschweißen eignen sich alle Legierungen jedoch neigen Magnesium und Zinn zum Verdampfen während des Schweißvorgangs Lichtbogenhandschweißen wird nur noch selten verwendet meist zur Gussnachbesserung
Löten gestaltet sich wegen der sich bildenden Oxidschicht an Luft schwierig
Genutzt werden sowohl Hart- als auch Weichlöten mit speziellen Flussmitteln
Alternativ kann Aluminium auch ohne Flussmittel mit Ultraschall gelötet werden dabei wird die Oxidschicht mechanisch während des Lötvorganges aufgebrochen
Aluminium in Natur und Organismen
Aluminium im menschlichen Körper
Aluminium ist kein essentielles Spurenelement und gilt für die menschliche Ernährung als entbehrlich Im menschlichen Körper befinden sich durchschnittlich etwa <num> bis <num> Milligramm Aluminium Diese verteilen sich zu ungefähr <num> Prozent auf das Lungengewebe zu <num> Prozent auf die Weichteile und zu weiteren <num> Prozent auf die Knochen
Aluminium ist damit ein natürlicher Bestandteil des menschlichen Körpers
<num> bis <num> Prozent der üblicherweise in Lebensmitteln aufgenommenen Menge von Aluminium <num> bis <num> mg pro Tag werden unresorbiert über den Kot wieder ausgeschieden
Chelatbildner Komplexbildner wie Citronensäure können die Resorption auf <num> bis <num> Prozent steigern
Auch die Aufnahme von Aluminiumsalzen über den Magen-Darm-Trakt ist gering sie variiert aber in Abhängigkeit von der chemischen Verbindung und ihrer Löslichkeit dem pH-Wert und der Anwesenheit von Komplexbildnern
Man schätzt dass <num>
beziehungsweise <num>
des in der Nahrung beziehungsweise im Trinkwasser erhaltenen Aluminiums im Magen-Darm-Trakt absorbiert werden Die Eliminierung von in den Organismus gelangten wasserlöslichen Aluminiumsalzen erfolgt innerhalb weniger Tage vorwiegend durch die Nieren über den Urin weniger über den Kot Bei Dialysepatienten mit einer eingeschränkten Nierenfunktion besteht daher ein erhöhtes Risiko einer Akkumulation im Körper mit toxischen Effekten etwa Knochenerweichungen und Schäden des Zentralnervensystems zusätzlich sind Dialysepatienten aufgrund für sie notwendiger pharmazeutischer Produkte Phosphatbinder einer höheren Aluminiumzufuhr ausgesetzt Aluminium das nicht über die Nieren ausgeschieden wird gelangt in die Knochen Dort wird es vergleichsweise sehr langsam eliminiert so dass man durch Modelschätzungen annimmt dass etwa <num>-<num>
der reorbierten Dosis sich im Körper anhäufen In einem Leben häuft man etwa <num> mg Aluminium im Körper an
Im Blut ist Al<num> überwiegend zu etwa <num>
an Transferrin gebunden
<num> Prozent liegen als AlPO<num>OH- <num> Prozent als Citrat-Komplex <num> Prozent als AlOH<num> und <num> Prozent als AlOH<num>- vor Das Blut Neugeborener enthält bereits Aluminiumionen die aus dem materalen Kreislauf stammen Die Serumkonzentrationen von etwa <num>-<num> μgl entspricht in etwa der von Erwachsenen
Pflanzen
Aluminium in Form verschiedener Salze Phosphate Silikate ist Bestandteil vieler Pflanzen und Früchte denn gelöste Al-Verbindungen werden durch Regen aus den Böden von den Pflanzen aufgenommen bei Säurebelastung der Böden infolge sauren Regens
ist dies vermehrt der Fall siehe dazu auch Waldschäden
Ein großer Teil des Bodens auf der Welt ist chemisch sauer
Liegt der pH-Wert unter <num> werden Al<num>-Ionen von den Wurzeln der Pflanzen aufgenommen
Dies ist bei der Hälfte des bebaubaren Lands auf der Welt der Fall
Die Ionen schädigen insbesondere das Wurzelwachstum der Feinwurzeln
Wenn die Pflanze nicht Aluminium-tolerant ist steht sie dann unter Stress
Zahlreiche Enzyme und signalübertragende Proteine sind betroffen die Folgen der Vergiftung sind noch nicht vollständig bekannt
In sauren metallhaltigen Böden ist Al<num> das Ion mit dem größten Potenzial zur Schädigung
Von der Modellpflanze
Arabidopsis
sind Transgene bekannt die deren Aluminium-Toleranz heraufsetzen und auch bei Kulturpflanzen sind tolerante Sorten bekannt
Der saure Regen hat beispielsweise in Schweden in den <num>er-Jahren die Seen übersäuert wodurch mehr Al<num>-Ionen in Lösung gingen und empfindliche Fische verendeten Auch in Norwegen wurde dieser Zusammenhang bei einem Forschungsprojekt in den <num>er-Jahren festgestellt
Bei pH-Werten über <num> ist Aluminium als polymeres Hydroxykation an der Oberfläche von Silicaten gebunden
Bei pH-Werten von <num> bis <num> steigt Anteil von mobilen Kationen
Bei Erhöhung der Schwefelsäurekonzentration durch sauren Regen bildet sich Aluminiumhydroxysulfat
In Lebensmitteln
Die meisten Lebensmittel enthalten in Spurenmengen auch Aluminium
Unverarbeitete pflanzliche Lebensmittel enthalten durchschnittlich weniger als <num> mgkg in der Frischmasse
Dabei streuen die Werte aufgrund unterschiedlicher Sorten Anbaubedingungen und Herkunft in erheblichem Maße So weisen beispielsweise Salat und Kakao deutlich höhere Durchschnittswerte auf
Schwarzer Tee kann Gehalte von bis zu <num> mgkg in der Trockenmasse aufweisen
Beim Kochen oder Aufbewahren in Aluminiumgeschirr oder in Alufolie kann es außer bei sauren Lebensmitteln nach einer Schätzung zu einer maximalen zusätzlichen Aufnahme von <num> mgTagPerson kommen
Bei sauren Lebensmitteln wie Sauerkraut oder auch Tomaten können aufgrund der Säurelöslichkeit wesentlich höhere Werte erreicht werden
Trink- und Mineralwässer weisen mit durchschnittlich <num>-<num> mgl im Gegensatz zur Nahrung geringe Gehalte auf und stellen somit nur einen kleinen Beitrag zur täglichen Aluminium-Aufnahme
Die Trinkwasserverordnung legt einen Grenzwert von <num> mgl fest
Trinkwasser darf in Deutschland Österreich und der Schweiz keine höheren Werte aufweisen
Nach einer Schätzung nimmt der erwachsene Europäer im Durchschnitt zwischen <num> und <num> mg Aluminium pro Tag über die Nahrung auf Dies entspricht einer wöchentlichen Aufnahme von <num> bis <num> mg Aluminium pro kg Körpergewicht bei einem <num> kg schweren Erwachsenen
Die großen Unsicherheiten beruhen auf den unterschiedlichen Ernährungsgewohnheiten und der variablen Gehalte an Aluminium in den Lebensmitteln auch innerhalb eines Landes aufgrund verschiedener Erhebungen Falls Säuglinge mit Fertignahrung ernährt werden kann die Aluminiumkonzentration im Blut bei <num> μgl liegen Eine mögliche gesundheitliche Schädigung ist nicht bekannt
Die Europäische Behörde für Lebensmittelsicherheit Efsa legt eine tolerierbare wöchentliche Aufnahme TWI von <num> mg Aluminium pro kg Körpergewicht fest
Aluminium ist als Lebensmittelzusatzstoff unter der Bezeichnung E <num> ausschließlich als Farbmittel für Überzüge von Zuckerwaren und als Dekoration von Kuchen und Keksen erlaubt
Weiterhin ist Aluminium zum Färben von Arzneimitteln und Kosmetika zugelassen
Bei der Untersuchung von Laugengebäck Brezeln Stangen Brötchen aus Bäckereien wurde Aluminium nachgewiesen das in das Lebensmittel gelangt wenn bei der Herstellung von Laugengebäck Aluminiumbleche verwendet werden
Während Bier in Aluminiumfässern transportiert wird hat sich für den Weintransport der Werkstoff Aluminium nicht durchgesetzt
Ein kurzfristiger Kontakt schadet nicht doch können nach längerem Kontakt Weinfehler in Geruch und Geschmack oder als Trübung auftreten vor allem beim offenen Stehen an der Luft
Toxizität
Bei eingeschränkter Nierenfunktion und bei Dialyse-Patienten führt die Aufnahme von Aluminium zu progressiver Enzephalopathie Gedächtnis- und Sprachstörungen Antriebslosigkeit und Aggressivität durch Untergang von Hirnzellen und zu fortschreitender Demenz zu Osteoporose Arthritis mit Knochenbrüchen und zu Anämie
weil Aluminium dieselben Speichereiweiße wie Eisen besetzt
Dies wurde in den <num>er Jahren bei langjährigen Hämodialysepatienten durch starke Aluminiumzufuhr beobachtet Dialysis Encephalopathy Syndromeimp
Speziell im Hinblick auf die Verwendung in Deodorants und Lebensmittel-Zusatzstoffen werden die gesundheitlichen Auswirkungen von Aluminium kontrovers diskutiert
So wurde Aluminium mehrfach kontrovers als Faktor im Zusammenhang mit der Alzheimer-Krankheit in Verbindung gebracht
Laut einer Studie des Bundesinstituts für Risikobewertung BfR vom Juli <num> wurde im allgemeinen Fall zum Zeitpunkt der Erstellung der Studie aufgrund der vergleichsweise geringen Menge kein Alzheimer-Risiko durch Aluminium aus Bedarfsgegenständen erkannt jedoch sollten vorsorglich keine sauren Speisen in Kontakt mit Aluminiumtöpfen oder -folie aufbewahrt werden Eine Neubewertung erfuhr im Februar <num> die Verwendung von aluminiumhaltigen Deodorants und Kosmetikartikel durch das Bundesinstitut für Risikobewertung Aluminiumsalze aus solchen Produkten können durch die Haut aufgenommen werden und die regelmäßige Benutzung über Jahrzehnte hinweg könnte möglicherweise zu gesundheitlichen Beeinträchtigungen beitragen
Die britische Alzheimer-Gesellschaft mit Sitz in London vertritt den Standpunkt dass die bis <num> erstellten Studien einen kausalen Zusammenhang zwischen Aluminium und der Alzheimer-Krankheit nicht überzeugend nachgewiesen haben Dennoch gibt es einige Studien wie z B
die PAQUID-Kohortenstudie in Frankreich mit einer Gesundheitsdatenauswertung von <num> Personen im Alter ab <num> Jahren seit <num> bis zur Gegenwart in welchen eine Aluminium-Exposition als Risikofaktor für die Alzheimer-Krankheit angegeben wird
Demnach wurden viele senile Plaques mit erhöhten Aluminium-Werten in Gehirnen von Alzheimer-Patienten gefunden
Es ist jedoch unklar ob die Aluminium-Akkumulation eine Folge der Alzheimer-Krankheit ist oder ob Aluminium in ursächlichem Zusammenhang mit der Alzheimer-Krankheit zu sehen ist Die Deutsche Alzheimer Gesellschaft sieht keinen überzeugenden Zusammenhang zwischen Aluminium-Aufnahme und Alzheimer-Krankheit
Aluminium gehört zu den nicht essentiellen Spurenelementen bei der Toxizität kommt es im Wesentlichen auf die Menge an <num> mgl Aluminium im Blut gilt als Normalwert Werte über <num> mgl sprechen für übermäßige Belastung und Werte über <num> mgl im Blut gelten als toxisch
Aspekte der Ökobilanz
DateiAluminium foamjpg DateiRecycling-Code-<num>svg
Die Herstellung von Aluminium ist sehr energieaufwendig
Allein für die Schmelzflusselektrolyse zur Gewinnung eines Kilogramms Aluminium werden je nach Errichtungsdatum und Modernität der Anlage zwischen <num> und <num> kWh elektrische Energie benötigt Bei der Stromerzeugung für die Produktion von einem Kilogramm Aluminium werden im deutschen Kraftwerkspark <num> kg CO<num> freigesetzt im weltweiten Durchschnitt etwa <num> kg
Es ist aber auch zu bedenken dass aufgrund des Kostenfaktors Energie die Elektrolyse verstärkt an Orten erfolgt an denen auf billige CO<num>-emissionsarme Wasserkraft zurückgegriffen werden kann wie etwa in Brasilien Kanada Venezuela oder Island Allerdings ist auch bei Verwendung von Elektrizität aus vollständig regenerativen Energien die Produktion von Aluminium nicht CO<num>-frei da der bei der Schmelzflusselektrolyse entstehende Sauerstoff mit dem Kohlenstoff der Elektroden zu CO<num> reagiert
Die Verbrauchswerte für Roh-Aluminium erhöhen sich durch Transport- und Verarbeitungsanteile für das Wiederaufschmelzen Gießen Schleifen Bohren Polieren etc auf ca <num> kg CO<num> pro kg Aluminium-Konsumgut
Die europaweite Recyclingrate von Aluminium liegt bei <num> Prozent
In Österreich gelangen laut einer Studie aus dem Jahr <num> <num> Tonnen Aluminium pro Jahr über Verpackungen in den Konsum ebenso gelangen <num> Tonnen Aluminium ohne Wiederverwertung in den Hausmüll dabei sind unter anderem auch die Aluminiumhaushaltsfolien eingerechnet die nicht als Verpackung gelten
<num> Prozent der Verpackungen im Restmüll sind Aluminiumgetränkedosen
Diese liegen nach der Müllverbrennung in der Asche noch metallisch vor und machen in Europa durchschnittlich <num> Prozent der Asche aus In der EU werden durchschnittlich <num> Prozent des in der Bodenasche enthaltenen Aluminiums zurückgewonnen
Durch den Abbau des Erzes Bauxit werden große Flächen in Anspruch genommen die erst nach einer Rekultivierung wieder nutzbar werden
Um eine Tonne Aluminium herzustellen werden vier Tonnen Bauxit benötigt
Dies erzeugt zehn Tonnen Abraum Zudem entstehen bei der Herstellung des Aluminiumoxids nach dem Bayer-Verfahren ca drei Tonnen von eisenreichem alkalischen Rotschlamm der kaum wiederverwertet wird und dessen Deponierung oder sonstige Entsorgung große Umweltprobleme aufwirft siehe entsprechende Abschnitte unter
Rotschlamm
und
Bauxitbergbau in Australien
Positiv ist hingegen die gute Wiederverwendbarkeit von Aluminium hervorzuheben wobei die Reststoffe streng getrennt erfasst und gereinigt werden müssen Aluminiumrecycling Recycling-Code-<num> ALU Aluminium ist dabei besser rezyklierbar als Kunststoffe wegen Downcycling bei nicht sortenreiner Erfassung jedoch etwas schlechter wiederverwertbar als Stahl
Beim Aluminiumrecycling wird nur <num> Prozent der Energiemenge der Primärproduktion benötigt Durch Leichtbau mit Aluminiumwerkstoffen beispielsweise Aluminiumschaum Strangpressprofile wird Masse von beweglichen Teilen und Fahrzeugen gespart was zur Einsparung von Treibstoff führen kann
Aluminium ist durch seine Selbstpassivierung korrosionsbeständiger als Eisen und erfordert daher weniger Korrosionsschutzmaßnahmen
Nachweis
Aluminiumsalze weist man durch Glühen mit verdünnter Kobaltnitratlösung CoNO<num><num> auf der Magnesia-Rinne nach
Dabei entsteht das Pigment Thénards Blau ein Cobaltaluminiumspinell mit der Formel CoAl<num>O<num>
Es wird auch Kobaltblau oder Cobaltblau Dumonts Blau Coelestinblau Cobaltaluminat oder - nach dem Entdecker des Pigments Josef Leithner - Leithners Blau genannt
Nachweis mittels Kryolithprobe
Die Probelösung wird alkalisch gemacht um Aluminium als Aluminiumhydroxid AlOH<num> zu fällen
Der Niederschlag wird abfiltriert und mit einigen Tropfen Phenolphthalein versetzt dann gewaschen bis keine Rotfärbung durch Phenolphthalein mehr vorhanden ist
Wenn anschließend festes Natriumfluorid NaF auf den Niederschlag gestreut wird verursachen Hydroxidionen die bei der Bildung von Kryolith Na<num>AlF<num> freigesetzt werden eine erneute Rotfärbung des Phenolphthaleins
Nachweis als fluoreszierender Morinfarblack
DateiAluminium-Morin-Reaktionsvg Die Probe wird mit Salzsäure HCl versetzt und eventuell vorhandenes Aluminium somit gelöst
Anschließend wird die Probelösung mit Kaliumhydroxid KOH stark alkalisch gemacht
Gibt man nun einige Tropfen der Probelösung zusammen mit der gleichen Menge Morin-Lösung auf eine Tüpfelplatte und säuert anschließend mit konzentrierter Essigsäure Eisessig CH<num>COOH an so ist unter UV-Strahlung λ
<num> nm eine grüne Fluoreszenz beobachtbar
Der Nachweis ist dann sicher wenn diese Fluoreszenz bei Zugabe von Salzsäure wieder verschwindet
Grund hierfür ist dass AlIII in neutralen sowie essigsauren Lösungen in Verbindung mit Morin eine fluoreszierende kolloidale Suspension bildet
Verbindungen
DateiCorundum-<num>jpg DateiHybridschaltungjpg DateiKaaliumi maarjase monikristallid<num>JPG
Aluminiumoxid Al<num>O<num> englisch alumina auch als Tonerde oder Korund bekannt liegt als weißes Pulver oder in Form sehr harter Kristalle vor
Es ist das Endprodukt des Bayer-Verfahrens und dient in erster Linie als Ausgangsmaterial für die Aluminiumgewinnung Schmelzflusselektrolyse
Es wird darüber hinaus als Schleif- oder Poliermittel und für Uhrensteine Ziehsteine und Düsen verwendet
In keramischer Form dient es als Isolierstoff Konstruktionskeramik als Substratmaterial für Dickschichtschaltkreise als Grundplatte von Leistungshalbleitern und in transparenter Form als Entladungsgefäß von Natriumdampf-Hochdrucklampen
Aluminiumhydroxid AlOH<num> wird ebenfalls nach dem Bayer-Verfahren gewonnen und ist das wichtigste Ausgangsmaterial zur Erzeugung anderer Al-Verbindungen vor allem für Aluminate
Als reines Produkt wird es als Füllstoff und zum Brandschutz in Kunststoffen und Beschichtungen eingesetzt
Aluminiumchlorid Polyaluminiumchlorid und Aluminiumsulfat werden vor allem als Flockungsmittel in der Wasseraufbereitung Abwasserreinigung und der Papierindustrie eingesetzt
Natriumaluminat NaAlOH<num> wird ebenfalls als Flockungsmittel verwendet und ist weiterhin Rohstoff für die Zeolith-Produktion Titandioxid-Beschichtung und Calciumaluminatsulfat-Herstellung
Zeolithe Alumosilikate als Ionenaustauscher in Lebensmitteln und in Waschmitteln zur Wasserenthärtung
Alaune Kaliumaluminiumsulfat KAlSO<num><num><num>H<num>O
Wegen seiner adstringierenden Wirkung als Rasierstift eingesetzt zum Stillen von kleinen Blutungen
Aluminiumdiacetat bekannt als essigsaure Tonerde für entzündungshemmende Umschläge
Aluminiumorganische Verbindungen wie etwa Triethylaluminium werden im großtechnischen Maßstab als Katalysatoren in der Polyethylen-Herstellung eingesetzt
Ein weiteres Anwendungsgebiet ist die Halbleitertechnik
Hier werden flüchtige Aluminiumalkyle Trimethylaluminium Triethylaluminium etc als Vorstufen zur CVD chemical vapor deposition von Aluminiumoxid verwendet das man als Isolator und Ersatz für das nicht ausreichend isolierende Siliciumdioxid einsetzt
Aluminiumoxynitrid ist ein transparenter keramischer Werkstoff
Aluminiumnitrid ist ein Konstruktions- und Isolationswerkstoff und zeichnet sich durch sehr hohe Wärmeleitfähigkeit bei Raumtemperatur aus
Außerdem könnte die hohe Bandlücke die Anwendung als Wide-Bandgap-Halbleiter ermöglichen
Lithiumaluminiumhydrid LiAlH<num> ist ein starkes Reduktionsmittel welches weitverbreitet bei der Synthese organischer Verbindungen ist
Phosphate Aluminiumphosphate sind Aluminiumsalze der Phosphorsäure
Aufgrund der Eigenschaft der Phosphorsäure beziehungsweise des Phosphat-Anions PO<num> <num>- unter bestimmten Bedingungen Wasser abzuspalten und infolgedessen zu polymerisieren sind verschiedene Aluminiumphosphate bekannt Aluminiumorthophosphat AlPO<num>
Aluminiummetaphosphat AlPO<num><num>
Monoaluminiumphosphat AlH<num>PO<num><num>
Aluminiumpolyphosphat
In der Natur treten Aluminiumphosphate meist in Form von Doppelsalzen auf
Beispiele hierfür sind etwa der Wavellit Al<num>PO<num><num>F OH<num>
<num>H<num>O oder der Türkis ein Mischphosphat aus Kupfer und AluminiumEisen CuAlFe<num>PO<num><num>OH<num>
<num> H<num>O
Unter besonderen Bedingungen tritt Aluminium auch einwertig auf
Diese Verbindungen werden zur Gewinnung von hochreinem Aluminium genutzt Subhalogeniddestillation
Siehe auch
Liste der Aluminiumhütten
Liste der größten Aluminiumproduzenten
Literatur
Zur Geschichte
Hans Joliet Hrsg Aluminium - Die ersten hundert Jahre VDI Verlag <num> ISBN <num>-<num>-<num>-<num>
Deutsche Fachliteratur
Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage
Springer <num> ISBN <num>-<num>-<num>-<num>-<num>
Aluminium-Taschenbuch
Aluminium-Verlag Düsseldorf Band <num> Grundlagen und Werkstoffe <num> Auflage <num>
Band <num> Umformen von Aluminium-Werkstoffen Gießen von Aluminium-Teilen Oberflächenbehandlung von Aluminium Recycling und Ökologie <num> Auflage <num> <num> S
Band <num> Weiterverarbeitung und Anwendung <num> Auflage <num> <num> S
Luitgard Marschall Aluminium
Metall der Moderne
Oekom München <num> ISBN <num>-<num>-<num>-<num>-<num>
Englische Fachliteratur
George E Totten D Scott MacKenzie Handbook of Aluminum
Marcel Dekker Yew York Basel Band <num> Physical Metallurgy and Processes
<num> <num> S
Band <num> Alloy Production and Materials Manufacturing
<num> <num> S
Joseph R Davis Hrsg Aluminum and Aluminum Alloys
<num> Auflage <num> <num> S
Weblinks
MATERIAL ARCHIV Aluminium - Umfangreiche Materialinformationen und Bilder
Newsseite des Gesamtverbands der Aluminiumindustrie
Lars Fischer
Wie gefährlich ist Aluminium
Spektrumde <num> Juli <num>
Einzelnachweise
Norman N Greenwood Alan Earnshaw Chemie der Elemente Wiley-VCH Weinheim <num> ISBN <num>-<num>-<num>-<num> N A Figurowski Die Entdeckung der chemischen Elemente und der Ursprung ihrer Namen in deutscher Übersetzung von Leo KorniljewErnst Lemke Moskau <num> ISBN <num>-<num>-<num>-<num> S <num> Norman N Greenwood Alan Earnshaw Chemistry of the Elements <num> Auflage Butterworth-Heinemann <num> ISBN <num>-<num>-<num>-<num> S <num>
auf Webmineral englisch Fundortliste für Aluminium beim Mineralienatlas und bei Mindat IMACNMNC List of Mineral Names November <num> PDF <num> MB Aluminium siehe S <num> IMACNMNC List of Mineral Names <num> PDF <num> MB Aluminium siehe S <num> Rudolf Debar Die Aluminium-Industrie <num> Auflage Springer <num> S <num> ff
PDF Seminararbeit <num> kB S <num> Matthias Dienhart
PDF <num> MB Dissertation Rheinisch-Westfälischen Technischen Hochschule Aachen Juni <num> S <num> Rainer Quinkertz Optimierung der Energienutzung bei der Aluminiumherstellung Dissertation Rheinisch-Westfälische Technische Hochschule Aachen <num> S <num>-<num> R Feige G Merker
PDF Udo Boin Thomas Linsmeyer Franz Neubacher Brigitte Winter Stand der Technik in der Sekundäraluminiumerzeugung im Hinblick auf die IPPC-Richtlinie Österreichisches Umweltbundesamt Wien <num> ISBN <num>-<num>-<num>-<num> umweltbundesamtat PDF Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> D R Askeland Materialwissenschaft Spektrum Heidelberg <num> ISBN <num>-<num>-<num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> <num> Der Technologie-Leitfaden von ELB
In Eloxalwerk Ludwigsburg
Website des Luftfahrt-BundesamtesGeorge E Totten D Scott MacKenzie Handbook of Aluminum Band <num> Physical Metallurgy and Processes Marcel Dekker Yew York Basel <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Preisindex an der London Metall Exchange D R Askeland Materialwissenschaft Spektrum Heidelberg <num> S <num> D R Askeland Materialwissenschaft Spektrum Heidelberg <num> S <num> world-aluminiumorg The Global Aluminium Industry <num> years from <num> PDF <num> kB abgerufen am <num> November <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num>vgl
Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num>Verheilung von Aluminium
Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> httpswwwspotlightmetalcomhow-environmentally-friendly-is-the-european-aluminium-industry-gal-<num>p<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> NA Bernd Leitenberger
In Bernd Leitenbergers Web Site Aluminium auf Feuerwerk-Wiki wwwfeuerwerknet Eberhard Roos Karl Maile Werkstoffkunde für Ingenieure <num> bearbeitete Auflage <num> Springer S <num> A Herbert Fritz Günter Schulze Fertigungstechnik <num> Auflage Springer Berlin <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> Rüdiger Bähr Urformen in Molitor Grote Herold Karpuschewski Einführung in die Fertigungslehre Shaker <num> S <num> Heiko Lickfett Wirtschaftliche Bedeutung der Gießereiindustrie in Andreas Bühring-Polaczek Walter Michaeli Günter Spur Hrsg Handbuch Urformen Hanser <num> S <num>-<num> Bernhard Ilschner Robert F Singer Werkstoffwissenschaften und Fertigungstechnik Eigenschaften Vorgänge Technologien <num> Auflage Springer Berlin <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Fritz Klocke Wilfried König Fertigungsverfahren <num> Umformen <num> Auflage Springer Heidelberg S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Eberhard Roos Karl Maile Werkstoffkunde für Ingenieure Grundlagen Anwendung Prüfung <num> Auflage Springer Berlin <num> S <num> Wilfried König Fritz Klocke Fertigungsverfahren <num> Drehen Bohren Fräsen <num> Auflage Springer <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> Thorsten Zurell Absaugung von Aluminium-Schleifstäuben und -Schweißrauchen im Automobilbau mit ex-geschützten Filtersystemen In
Gefahrstoffe - Reinhalt Luft <num> Nr <num><num> <num> S <num>-<num> Udo M Spornitz Anatomie und Physiologie Lehrbuch und Atlas für Pflege- und Gesundheitsfachberufe Springer Berlin <num> ISBN <num>-<num>-<num>-<num>-<num> Wilfried Puwein Das Waldsterben in Österreich und seine ökonomischen Folgen Nr <num> <num> wifoacat PDF <num> kB Aluminium in Lebensmitteln lebensmittelorg Safety of aluminium from dietary intake - Scientific Opinion of the Panel on Food Additives Flavourings Processing Aids and Food Contact Materials AFC In
The EFSA Journal <num> <num> S <num>-<num> doi<num>jefsa<num> Aluminium in der Datenbank für Lebensmittelzusatzstoffe Chemisches und Veterinäruntersuchungsamt Karlsruhe
PDF <num> H Eschnauer Die Verwendung von Aluminium in der Weinwirtschaft Vitis <num> <num> S <num>-<num> zitiert von S <num> vitis-veade PDF <num> kB H E Müller W Dünnleder W Mühlenberg R Ruckdeschel Legionellen - ein aktives Problem der Sanitärhygiene <num> Auflage expert-Verlag ISBN <num>-<num>-<num>-<num>-<num> S <num>
H J Gitelman Physiology of Aluminum in Man In Aluminum and Health CRC Press <num> ISBN <num>-<num>-<num>-<num> S <num>
Bundesinstitut für Risikobewertung Hrsg
PDF <num> kB <num> Juli <num> Bundesinstitut für Risikobewertung Hrsg
PDF <num> kB <num> Februar <num>
The Alzheimers Society Abgerufen am <num> Januar <num> H Lüllmann K Mohr M Wehling L Hein Pharmakologie und Toxikologie Thieme Verlag <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
auf staufenbielde
PDF S <num> Hans Daxbeck Adolf Merl Eva Ritter Paul H Brunner Analyse der Flüsse des lizenzierten Aluminiums in Österreich Technische Universität Wien Institut für Wassergüte und Abfallwirtschaft <num> rmaat PDF International Aluminium Journal Nr <num> <num> S <num> ff International Aluminium Journal Nr <num> <num> S <num> Uwe Kerkow Jens Martens Axel Müller
PDF Aachen Bonn Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> Manfred Sietz Stefan Seuring Ökobilanzierung in der betrieblichen Praxis Eberhard Blottner Taunusstein <num> S <num>
In The Economist <num> J Strähle E Schweda Jander
Blasius - Lehrbuch der analytischen und präparativen anorganischen Chemie <num> Auflage Hirzel Stuttgart <num> ISBN <num>-<num>-<num>-<num> S <num>
Antimon
von lateinisch Antimonium vermutlich von arabisch al-ithmîdun
Antimonsulfid bzw Stibnit ist ein chemisches Element mit dem Elementsymbol Sb von
Grau-Spießglanz und der Ordnungszahl <num> Im Periodensystem steht es in der <num> Periode und der <num> Hauptgruppe bzw <num> IUPAC-Gruppe oder Stickstoffgruppe
In der stabilen Modifikation ist es ein silberglänzendes und sprödes Halbmetall
Name Geschichte
Es wird auch vermutet dass der Name auf das spätgriechische anthemon dt Blüte zurückgeht
Damit sollten die stängelartigen Kristalle von Antimonsulfid beschrieben werden die büschelförmig erschienen und wie eine Blüte aussähen
Im <num> Jahrhundert findet sich der lateinische Begriff für die mineralische Arzneidroge antimonium
zur innerlichen Therapie von Krankheiten dann bei Constantinus Africanus
Im <num> Jahrhundert ging der Name Antimon als Bezeichnung auf das Metall über
Die koptische Bezeichnung für das Schminkpuder Antimonsulfid ging über das Griechische in das Lateinische stibium über
Die vom schwedischen Mediziner und Chemiker Jöns Jakob Berzelius Vater der modernen Chemie benutzte Abkürzung Sb wird noch heute als Elementsymbol genutzt
Eine späte legendäre Volksetymologie die von Samuel Johnson in seinem Wörterbuch verewigt wurde besagt dass der deutsche Mönch Basilius Valentinus die Beobachtung machte dass Schweine durch die Aufnahme von Antimon schnell fett wurden
Er probierte dies auch an seinen Ordensbrüdern aus woraufhin diese allerdings starben sodass der Begriff antimoine antimönchisch geprägt wurde aus dem später Antimon entstanden sei
Als Typlokalität für gediegenes Antimon gilt die Silbermine in der schwedischen Gemeinde Sala im Västmanland Allerdings war metallisches Antimon schon den Chinesen und Babyloniern bekannt
Einige seiner Verbindungen wurden schon in der Bronzezeit als Zuschlag zu Kupfer verwendet um Bronze herzustellen Funde von Velem-St
Vid in Ungarn
Vorkommen
DateiAntimony-<num>jpg Antimon ist ein selten vorkommendes Element
Da es in der Natur auch gediegen das heißt in elementarer Form gefunden werden kann wird es von der International Mineralogical Association IMA unter der System-Nr <num>CA<num> als Mineral anerkannt
Weltweit konnte gediegenes Antimon bisher Stand <num> an rund <num> Fundorten nachgewiesen werden
So unter anderem in mehreren Regionen von Australien in den bolivianischen Departements La Paz und Potosí Minas Gerais in Brasilien Schwarzwald Fichtelgebirge Oberpfälzer Wald Odenwald und im Harz in Deutschland Seinäjoki in Finnland mehreren Regionen von Frankreich Lombardei Piemont Sardinien und Trentino-Südtirol in Italien einigen Regionen von Kanada einigen Regionen von Österreich Ost- und Westsibirien und Ural in Russland neben Västmanland noch Dalarna Gästrikland Närke Södermanland Värmland und Västerbotten in Schweden in einigen Regionen der Slowakei Böhmen und Mähren in Tschechien sowie in vielen Regionen der USA Eine der weltweit bedeutendsten Lagerstätten für gediegen Antimon und Antimonerze ist der Murchison greenstone belt in der Murchison Range von Südafrika
Bisher sind <num> Antimon-Minerale bekannt Stand <num> Industriell genutzt wird überwiegend das Sulfid-Mineral Stibnit Sb<num>S<num> Grauspießglanz mit einem Gehalt von maximal <num>
Sb
Das Mineral mit dem höchsten Sb-Gehalt in einer chemischen Verbindung ist die natürliche Antimon-Arsen-Legierung Paradocrasit max <num>
Allerdings kommt sie mit nur drei Fundorten im Gegensatz zum Stibnit rund <num> Fundorte sehr viel seltener vor
Weitere Quellen für Antimon sind die Minerale Valentinit Sb<num>O<num> Weißspießglanz Breithauptit NiSb Antimonnickel Nickelantimonid Kermesit Sb<num>S<num>O Rotspießglanz und Sb<num>S<num> Goldschwefel
Gewinnung und Darstellung
DateiAntimon - Trend Förderungsvg Technisch wird Antimon aus dem Antimonglanz gewonnen
Ein Verfahren beruht auf dem Abrösten und der Reduktion mit Kohlenstoff Röstreduktionsverfahren
Eine andere Möglichkeit besteht darin die Reduktion mit Eisen durchzuführen Niederschlagsverfahren
Weltweit wurden zu Beginn des <num> Jahrhunderts zwischen <num> und <num> Tonnen pro Jahr an Antimon gefördert
Seit <num> hat sich damit die Fördermenge mehr als verzehnfacht
<num>
der Antimonproduktion findet in China statt Stand <num>
Eigenschaften
Modifikationen
Antimon kann in drei verschiedenen Modifikationen auftreten wobei metallisches bzw graues Antimon die beständigste Modifikation ist
Unter Normalbedingungen kristallisiert Antimon trigonal in rhomboedrischer Aufstellung in der nach der Hermann-Mauguin-Symbolik beschriebenen Raumgruppe
mit den Gitterparametern a
<num> pm und c
<num> pm sowie sechs Formeleinheiten pro Elementarzelle
Durch Abschrecken von Antimondampf an kalten Flächen entsteht amorphes schwarzes und sehr reaktives Antimon welches sich durch Erhitzen wieder in metallisches Antimon umwandelt
Durch elektrolytische Herstellung entsteht explosives Antimon das beim Ritzen explosionsartig aufglühend und funkensprühend in metallisches Antimon übergeht
Diese Form enthält jedoch immer etwas Chlor und kann nicht als Modifikation betrachtet werden Gelbes Antimon ist ebenfalls keine eigenständige Modifikation sondern eine hochpolymere chemische Verbindung mit Wasserstoff
Physikalische Eigenschaften
Metallisches Antimon ist silberweiß stark glänzend blättrig-grobkristallin
Es lässt sich aufgrund seiner Sprödigkeit leicht zerkleinern
Elektrische und thermische Leitfähigkeit sind gering
Chemische Eigenschaften
Mit naszierendem Wasserstoff reagiert Antimon zum instabilen Antimonhydrid SbH<num>
Von Luft und Wasser wird Antimon bei Raumtemperatur nicht angegriffen
Oberhalb des Schmelzpunkts verbrennt es in Luft mit bläulich-weißer Flamme zu AntimonIII-oxid
In heißen konzentrierten Mineralsäuren löst es sich auf
Mit den Halogenen reagiert es schon bei Raumtemperatur heftig zu den entsprechenden Halogeniden
In Verbindungen liegt Antimon überwiegend in den Oxidationsstufen <num> und <num> vor
In Metallantimoniden wie Kaliumantimonid K<num>Sb bildet es Sb<num>--Ionen
Isotope
Es existieren zwei stabile Antimon-Isotope <num>Sb und <num>Sb
Verwendung
Legierungen
Der überwiegende Teil des hergestellten Antimons wird zu Legierungen verarbeitet und zeigt dabei folgende Eigenschaften
Es dient zur Härtung von Blei- und Zinnlegierungen
Im Gegensatz zu den meisten anderen Metallen dehnt es sich beim Abkühlen der Schmelze aus infolge Umwandlung in eine andere Modifikation Der Antimongehalt kann so eingestellt werden dass solche Legierungen beim Abkühlen nicht schrumpfen oder sich sogar etwas ausdehnen bei in Gießformen hergestellten Teilen presst sich das Metall dadurch beim Erstarren in alle Ecken und Winkel so dass auch komplizierte Formen und stark gemusterte Oberflächen lunkerfrei hergestellt werden können
Wichtige Legierungen
Blei-Antimon-Legierungen Hartblei Letternmetall Lagermetall Akkumulatoren-Blei Bleimantel für Erdkabel
Zinn-Antimon-Legierungen Britanniametall Lagermetall
Herstellung von Halbleitern z B
durch Dotierung von Silicium zur Herstellung von III-V-Verbindungshalbleitern
Zinn-Antimon-Kupferlegierungen Babbit-Metall für Lagermetalle
Zinn-Antimon-Kupfer-Bleilegierungen für Zinngeschirr und andere Gebrauchsartikel aus Zinn
so genanntes Lötzinn oder Weichlot
Aluminium-Antimon Gallium-Antimon Indium-Antimon für Infrarot- und Hall-Effekt-Geräte
Schrumpffreie Antimon-Legierungen für Präzisionsguss
Medizin
Antimon bzw ein aus Antimonerz gewonnenes Präparat wurde im <num> und <num> Jahrhundert zu einem iatrochemischen Leitarzneimittel war aber - wie auch andere paracelsische Medikamente - umstritten und in Frankreich zwischen <num> und <num> auch verboten
Brechweinstein wurde lange als brechreizerregendes Mittel verwendet Antimonpille heute wird es noch manchmal verwendet um den Mageninhalt von Vögeln zu untersuchen
Sowohl Schistosomiasis als auch Trypanosomen
wurden beginnend Anfang des <num> Jahrhunderts mit Brechweinstein Kaliumantimonyltartrat bekämpft
Brechweinstein wurde hergestellt indem man für einen Tag Wein in einem Antimonbecher lagerte und diesen dann austrank
Inzwischen kommen effektivere und verträglichere Medikamente zur Anwendung
Antimonpräparate werden meist als weniger toxische pentavalente Formen zur medikamentösen Therapie der Leishmaniose
und Schistosomiasis eingesetzt allerdings in entwickelten Ländern nicht mehr als Mittel der ersten Wahl
Hierbei hemmt Antimon das Enzym Phosphofructokinase das den geschwindigkeitsbestimmenden Schritt der Glykolyse darstellt
Weiteres
DateiStreichholzjpg
Bestandteil von Sprengstoffzündern und bleihaltiger Munition
Antimontrisulfid in Bremsbelägen von Fahrzeugen
AntimonV-sulfid
zur Herstellung Vulkanisieren von rotem Kautschuk Beispiel Labor-Gummischläuche
als roter Bestandteil des Zündkopfes in Streichhölzern
früher als Augenschminken und in der Augenheilkunde Augenerweiterer
Antimonchromat als gelbes Farbpigment
Antimonoxide Katalysator zur Herstellung von Polyester und PET AntimonIII-oxid
als Weißpigment zur Färbung von Polystyrol Polyethylen und Polypropylen
Herstellung weißer Glasuren und Fritten Läuterung von Bleiglas
mit Zinn dotiert als transparent-leitfähige Beschichtung ATO Antimon-Tin-Oxide beispielsweise auf Gläsern zur Herstellung von Displays oder in elektrisch leitfähigen Pigmenten Minatec für Fußbodenbeläge zur Ableitung elektrostatischer Aufladungen
in Pigmenten Lazerflair für die Laser-Markierung von Kunststoffteilen wegen der starken Absorption von Infrarot-Strahlung üblicher Markierungslaser NdYAG
in Tarnanstrichen wegen der starken Infrarot-Absorption
als Flammschutzmittel und als Bestandteil von flammfesten und flammhemmenden Farben Kunststoffen und Textilien für Kabelumhüllungen Autositzbezüge Vorhangstoffe Kinderbekleidung u Ä
Antimonsalze als Bestandteil von Pestiziden Beizen und Feuerwerksartikeln
Scheidemittel für Gold Zur Ausfällung von Silber aus Goldschmelze
Toxizität
Antimon kann bereits bei Ingestion von <num> bis <num> mg tödlich sein
In der Toxikologie sind drei Antimon-Formen bekannt von denen das gasförmige Antimonhydrid Stiban SbH<num> die gefährlichste Form ist die eine massive Hämolyse induziert
Nach der Toxizität folgt Brechweinstein mit dreiwertigem trivalentem Antimon während fünfwertiges Antimon am wenigsten toxisch ist
Das trivalente Antimon wird innerhalb der ersten zwei Stunden nach der Einnahme zu <num>
in rote Blutkörperchen aufgenommen und damit vorwiegend in stark durchbluteten Organen angereichert
Die Exkretion erfolgt vorwiegend durch Bindung an Glutathion über die Galle mit entsprechend hohem enterohepatischen Kreislauf und nur ein geringer Teil wird über die Nieren ausgeschieden
Kaliumantimonyltartrat wird zu <num>
innerhalb des ersten Tages nach Aufnahme ausgeschieden die übrigen <num>
aufgrund einer langsameren Eliminationskinetik über <num> Tage
Es wird vermutet dass Antimon ähnlich wie Arsen die Funktion des Pyruvatdehydrogenase-Komplexes hemmt und somit zu einem Mangel des intrazellulären Energieträgers Adenosintriphosphat ATP führt
Dabei kommt es zur Bildung von Chelatkomplexen zwischen dem Antimon und Thiol-Gruppen der entsprechenden Enzyme
Im Körper wirkt es in zahlreichen Organen toxisch so im Verdauungstrakt in der Leber in den Nieren im Herz und im Zentralnervensystem
Die höchste Konzentration erreicht Antimon in der Leber wo es zu einer Hepatitis bis hin zum Leberversagen kommen kann
Am Herzen kommt es zu EKG-Veränderungen mit Inversion und Verminderung der T-Welle und verlängertem QT-Intervall
Ein akutes Nierenversagen kann zur temporären oder permanenten Hämodialyse führen
Therapeutisch erfolgt bei einer Antimon-Vergiftung neben unterstützenden Maßnahmen wie Infusionstherapie sowohl zum Ausgleich des Flüssigkeitsverlustes durch das Erbrechen als auch zum Schutz der Nieren und engmaschiger Überwachung der Vitalfunktionen und des EKGs die Gabe von Aktivkohle N-Acetylcystein als Vorläufer des Glutathions zur vermehrten Sekretion und eines Chelatbildners z B
Dimercaprol
Ergebnisse aus Untersuchungen deuten darauf hin dass Antimonverbindungen Haut und Schleimhäute reizen
Diese Verbindungen lösen sich vermutlich aus Kunststoff und Textilien
Sicherheitshinweise und Grenzwerte
Von den Antimonverbindungen sind seitens der EU Antimonfluorid als giftig T und die Chloride als ätzend C eingestuft außerdem als umweltgefährlich N alle anderen Antimonverbindungen als gesundheitsschädlich Xn und umweltgefährlich N Antimon selbst ist dort nicht aufgeführt laut Sicherheitsdatenblatt ist es als reizend gekennzeichnet
Die Internationale Agentur für Krebsforschung IARC stuft AntimonIII-oxid als möglicherweise krebserzeugende Substanz ein
In der EU gilt für Trinkwasser ein Grenzwert von <num> µgl
Untersuchungen von in PET-Flaschen abgefüllten Fruchtsäften für die keine Richtlinien existieren ergaben Antimonkonzentrationen bis zu <num> µgl in unverdünnten Saftkonzentraten
Antimon wurde <num> von der EU gemäß der Verordnung EG Nr <num><num> REACH im Rahmen der Stoffbewertung in den fortlaufenden Aktionsplan der Gemeinschaft CoRAP aufgenommen
Hierbei werden die Auswirkungen des Stoffs auf die menschliche Gesundheit bzw die Umwelt neu bewertet und ggf Folgemaßnahmen eingeleitet
Ursächlich für die Aufnahme von Antimon waren die Besorgnisse bezüglich Exposition von Arbeitnehmern hoher aggregierter Tonnage hohes Risikoverhältnis Risk Characterisation Ratio RCR und weit verbreiteter Verwendung sowie der möglichen Gefahr durch krebsauslösende Eigenschaften
Die Neubewertung läuft seit <num> und wird von Deutschland durchgeführt
Nachweis
DateiFlammenfärbungSbpng Vorproben
Flammenfärbung Flamme fahlblau wenig charakteristische Phosphorsalzperle Farblos gestört durch alle Elemente die eine farbige Perle erzeugen
Nachweisreaktion
Reduktion durch unedle Metalle zum Beispiel Eisen Zink oder Zinn
In nicht zu sauren Lösungen reduzieren unedle Metalle Antimon-Kationen SbIII SbV und SbIIIV zu metallischem Antimon
<num> Sb<num>
<num> Fe
<num> Sb
<num> Fe<num>
Die auf Antimon zu prüfende Substanz wird in salzsaure Lösung gegeben und mit Eisenpulver versetzt
Es entsteht ein schwarzer flockiger Niederschlag aus metallischem Antimon in der Lösung oder direkt am Eisen
Auch der Nachweis an einem Eisennagel ist möglich
Dabei ist eine schwarze Ablagerung am Nagel ein Nachweis für Antimon welches sich hier elementar niedergeschlagen hat
Die Marshsche Probe gestattet einen eindeutigen Nachweis von Antimon
Wenn die pyrolytisch abgeschiedene Substanz dunkel glänzender Spiegel sich nicht in ammoniakalischem Wasserstoffperoxid löst sind Arsen und Germanium als mögliche Alternativen ausgeschlossen
Die hochempfindliche Bestimmung winziger Antimonspuren erfolgt durch die Hydridtechnik der Atomspektrometrie
Hierbei wird im Prinzip die Marshsche Probe mit der Atomabsorptionsspektrometrie gekoppelt
Die Matrixeffekte der Probelösung lassen sich dadurch sehr wirksam unterdrücken
Eine weitere Methode besteht darin eine wässrige Lösung in der Antimonionen enthalten sind mit Rhodamin-B-Lösung zu versetzen
Es bildet sich ein farbiger Komplex der mit Isopropylether extrahierbar ist
Dieser Nachweis ist allerdings recht unspezifisch da auch Gold- Cadmium- Gallium Thallium- Uran- und Wolfram-ionen farbige Komplexe bilden
Verbindungen
Antimonwasserstoff auch Monostiban SbH<num> genanntGiftiges Gas das sich aus Antimon und einwirkenden Säuren bildet
Distiban Sb<num>H<num>
Halogenverbindungen
AntimonV-fluorid SbF<num> bildet nach VSEPR eine quadratische Pyramide aus und hybridisiert dabei zu sp<num>d
AntimonV-chlorid SbCl<num>
AntimonIII-fluorid SbF<num>
AntimonIII-chlorid SbCl<num>
AntimonIII-bromid SbBr<num>
AntimonIII-iodid SbI<num>
Sauerstoffverbindungen
AntimonIII-oxid Antimontrioxid Sb<num>O<num>
AntimonIIIV-oxid Antimontetroxid Sb<num>O<num>
AntimonV-oxid Antimonpentaoxid Sb<num>O<num>
antimonige SäureAntimontrihydroxid H<num>SbO<num>SbOH<num>
antimonige SäureAntimonIII-Säure SbOOH bzw HSbO<num>
Antimonsäure HSbOH<num>
Schwefelverbindungen
Antimontrisulfid auch Antimonglanz genannt Sb<num>S<num>Grauschwarze metallisch glänzende Stängel
Ausgangsstoff zur Herstellung metallischen Antimons
Löslich in starken Säuren
Verwendung für Streichhölzer Rubingläser und Tarnanstriche Reflexion von IR-Licht
Antimonpentasulfid früher als Goldschwefel bezeichnet Sb<num>S<num>
Sonstige Verbindungen
AntimonV-chloridfluorid SbCl<num>F Katalysator für die Herstellung von Polytetrafluorethylen Teflon
Aluminiumantimonid AlSb
Galliumantimonid GaSb
Indiumantimonid InSb
Literatur
Willem Frans Daems Stimmi - Stibium - Antimon
Eine substanzhistorische Betrachtung
Weleda-Schriftenreihe <num>
Arlesheim Schwäbisch Gmünd <num>
Weblinks
Mineralienatlas Antimon Wiki
Chemie im Alltag Mozart - Opfer einer Antimonvergiftung
Einzelnachweise
Willem F Daems Zu Helmut Gebelein Alchemie München Eugen Diederichs <num> In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num> Doris Schwarzmann-Schafhauser Antimonstreit In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num> S <num> Mindat - Sala Silver Mine Sala Västmanland Sweden IMACNMNC List of Mineral names - Antimony englisch PDF <num> MB S <num> Mindat - Localities for Antimony englisch
auf wwwgeoscienceorgza englisch Webmineral - Mineral Species sorted by the element Sb Antimony Mindat - Paradocrasite Mindat - Stibnite ddcartetv Lautenschläger u a Taschenbuch der Chemie
Verlag Harri Deutsch Frankfurt am Main <num> Ulrich Arndt Der Magnet der Weisen - Alchemistische Transmutation des Antimon In Paracelsus November <num>
S <num>-<num> Online-Version Wolf-Dieter Müller-Jahncke Christoph Friedrich Geschichte der Arzneimitteltherapie Deutscher Apothekerverlag Stuttgart <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> Doris Schwarzmann-Schafhauser Antimonstreit In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num> S <num> Katja Bauer
In
badische-zeitungde
<num> Juni <num> Wendy Macías Konstantopoulos Michele Burns Ewald Daniel S Pratt Case <num>-<num> A <num>-Year-Old Man with Intractable Vomiting after Ingestion of an Unknown Substance In
New England Journal of Medicine <num> <num> S <num>-<num> Bundesamt für Gesundheit Schweiz BAG
PDF <num> August <num> Hollemann-Wiberg Lehrbuch der anorganischen Chemie <num> Auflage S <num>
Argon griechisch
träge ist ein chemisches Element mit dem Symbol Ar bis <num> nur A und der Ordnungszahl <num> Im Periodensystem steht es in der <num> Hauptgruppe bzw der <num> IUPAC-Gruppe und zählt daher zu den Edelgasen
Wie die anderen Edelgase ist es ein farbloses äußerst reaktionsträges einatomiges Gas
In vielen Eigenschaften wie Schmelz- und Siedepunkt oder Dichte steht es zwischen dem leichteren Neon und dem schwereren Krypton
Argon ist das häufigste auf der Erde vorkommende Edelgas der Anteil an der Atmosphäre beträgt etwa <num>
Damit ist Argon der dritthäufigste Bestandteil der Erdatmosphäre nach Stickstoff und Sauerstoff
Dies ist großteils auf den Zerfall des Kaliumisotops <num>K zurückzuführen bei dem <num>Ar entsteht
Argon war das erste Edelgas das als Stoff entdeckt und gewonnen wurde daher der Name der im Grunde zu jedem Edelgas passt
Helium von griechisch helios für Sonne wurde vorher lediglich spektroskopisch im Sonnenlicht sowie in irdischen Proben nachgewiesen und Neon erst später entdeckt
Argon wurde <num> von Lord Rayleigh und William Ramsay durch fraktionierte Destillation von flüssiger Luft gefunden
Als preiswertestes Edelgas wird Argon in großen Mengen als Schutzgas etwa beim Schweißen und in der Produktion von manchen Metallen aber auch als Füllgas von Glühlampen verwendet
Geschichte
DateiJohn William Struttjpg Einen ersten Hinweis auf das später entdeckte Argon fand Henry Cavendish der <num> die Reaktivität der Luft erforschte
Er erzeugte elektrische Entladungen in einer bestimmten Menge Luft die mit Sauerstoff im Verhältnis von <num> angereichert war
Stickstoff und Sauerstoff reagierten miteinander und die entstandenen Stickoxide konnten ausgewaschen werden
Dabei blieb stets ein kleiner Rest nicht-reagierten Gases zurück
Cavendish erkannte jedoch nicht dass es sich dabei um ein anderes Element handelte und setzte seine Experimente nicht fort
Nachdem John William Strutt <num> Baron Rayleigh <num> die Dichte von aus Luft isoliertem Stickstoff bestimmt hatte fiel ihm auf dass aus Ammoniak gewonnener Stickstoff eine niedrigere Dichte aufwies
Es gab verschiedene Spekulationen zu diesem Befund so meinte James Dewar es müsse sich um ein N<num> also ein Stickstoff-Analogon zu Ozon handeln
Rayleigh wiederholte Cavendishs Experimente indem er in einer luftgefüllten Glaskugel elektrische Funken erzeugte und so Stickstoff und Sauerstoff zur Reaktion brachte
Nach Bestätigung von Cavendishs Ergebnis eines unreaktiven Rückstandes untersuchte William Ramsay diesen ab <num> durch Überleitung über heißes Magnesium genauer
Da Magnesium mit Stickstoff zum Nitrid reagiert konnte er dem Gemisch weiteren Stickstoff entziehen
Dabei stellte er eine Erhöhung der Dichte fest und fand schließlich ein bislang unbekanntes reaktionsträges Gas Am <num> Januar <num> gaben Ramsay und Rayleigh schließlich die Entdeckung des neuen Elements bekannt das sie nach dem altgriechischen argos träge Argon nannten Als William Ramsay ab <num> das aus der Luft isolierte Argon weiter untersuchte entdeckte er darin drei weitere Elemente die Edelgase Neon Krypton und Xenon
Erste technische Anwendungen fand das Gas in der Elektroindustrie Es wurden unter anderem Gleichrichter auf der Basis der Glimmentladung in Argon hergestellt die sogenannten
Tungar-Röhren
Vorkommen
Argon zählt im Universum zu den häufigeren Elementen in seiner Häufigkeit ist es vergleichbar mit Schwefel und Aluminium Es ist im Universum nach Helium und Neon das dritthäufigste Edelgas
Dabei besteht das primordiale Argon das etwa in der Sonne oder Gasplaneten wie Jupiter gefunden wird hauptsächlich aus den Isotopen <num>Ar und <num>Ar während das dritte stabile Isotop <num>Ar dort nur in geringer Menge vorkommt
Das Verhältnis von <num>Ar zu <num>Ar beträgt etwa <num>
Auf der Erde ist Argon dagegen das häufigste Edelgas
Es macht <num>
des Volumens der Atmosphäre ohne Wasserdampf aus und ist damit nach Stickstoff und Sauerstoff der dritthäufigste Atmosphärenbestandteil Die Zusammensetzung des terrestrischen Argons unterscheidet sich erheblich von derjenigen des primordialen Argons im Weltall
Es besteht zu über <num>
aus dem Isotop <num>Ar das durch Zerfall des Kaliumisotops <num>K entstanden ist
Die primordialen Isotope sind dagegen nur in geringen Mengen vorhanden
Da das Argon durch den Kaliumzerfall in der Erdkruste entsteht findet man es auch in Gesteinen
Beim Schmelzen von Gesteinen im Erdmantel gast das Argon aber auch das bei anderen Zerfällen entstehende Helium aus
Es reichert sich daher vorwiegend in den Basalten der ozeanischen Erdkruste an Aus den Gesteinen wird das Argon an das Grundwasser abgegeben
Daher ist in Quellwasser vor allem wenn es aus größerer Tiefe kommt Argon gelöst
Gewinnung und Darstellung
Die Gewinnung des reinen Argons erfolgt ausschließlich aus der Luft in der Regel im Rahmen der Luftverflüssigung im Linde-Verfahren
Das Argon wird dabei nicht in der Haupt-Rektifikationskolonne des Verfahrens von den Hauptluftbestandteilen getrennt sondern in einer eigenen Argon-Kolonne
In dieser wird durch Rektifikation zunächst Rohargon hergestellt das noch etwa <num>-<num>
Sauerstoff und <num>
Stickstoff enthält
Anschließend wird das Rohargon in weiteren Stufen gereinigt
Das Gasgemisch wird zunächst auf Raumtemperatur erwärmt und auf <num>-<num> bar verdichtet
Um den restlichen Sauerstoff zu entfernen wird danach Wasserstoff eingespritzt der an Edelmetall-Katalysatoren mit dem Sauerstoff zu Wasser reagiert
Nachdem dieses entfernt wurde wird in einer weiteren Kolonne das Argon das sich am unteren Ende der Kolonne anreichert vom restlichen Stickstoff getrennt so dass Argon mit einer Reinheit von <num>
Argon <num> produziert werden kann
Weitere Quellen für die Gewinnung von Argon sind die Produktion von Ammoniak im Haber-Bosch-Verfahren sowie die Synthesegasherstellung etwa zur Methanolproduktion
Bei diesen Verfahren die Luft als Ausgangsstoff nutzen reichern sich Argon und andere Edelgase im Produktionsprozess an und können aus dem Gasgemisch isoliert werden
Wie beim Linde-Verfahren werden auch hier die verschiedenen Gase durch Adsorption oder Rektifikation voneinander getrennt und so reines Argon gewonnen
Eigenschaften
Physikalische Eigenschaften
DateiArgon ice <num>jpg DateiFace-centered cubicsvg
Argon ist bei Normalbedingungen ein einatomiges farbloses und geruchloses Gas das bei <num> K -<num> C kondensiert und bei <num> K -<num> C erstarrt
Wie die anderen Edelgase außer dem Helium kristallisiert Argon in einer kubisch dichtesten Kugelpackung mit dem Gitterparameter a
<num> pm bei <num> K
Wie alle Edelgase besitzt Argon nur abgeschlossene Schalen Edelgaskonfiguration
Dadurch lässt sich erklären dass das Gas stets einatomig vorliegt und die Reaktivität gering ist
Mit einer Dichte von <num> kgm<num> bei <num> C und <num> hPa ist Argon schwerer als Luft es sinkt also ab
Im Phasendiagramm liegt der Tripelpunkt bei <num> K und <num> hPa der kritische Punkt bei <num> K <num> kPa sowie einer kritischen Dichte von <num> gcm<num>
In Wasser ist Argon etwas löslich
In einem Liter Wasser können sich bei <num> C und Normaldruck maximal <num> g Argon lösen
Chemische Eigenschaften
Als Edelgas reagiert Argon fast nicht mit anderen Elementen oder Verbindungen
Bislang ist nur das experimentell dargestellte Argonfluorohydrid HArF bekannt das durch Photolyse von Fluorwasserstoff in einer Argonmatrix bei <num> K gewonnen wird und anhand neuer Linien im Infrarotspektrum identifiziert wurde
Oberhalb von <num> K zersetzt es sich Nach Berechnungen sollten weitere Verbindungen des Argons metastabil sein und sich verhältnismäßig schwer zersetzen diese konnten jedoch experimentell bislang nicht dargestellt werden
Beispiele hierfür sind das Chloranalogon des Argonfluorohydrides HArCl aber auch Verbindungen bei denen das Proton durch andere Gruppen ersetzt ist etwa FArCCH als organische Argonverbindung und FArSiF<num> mit einer Argon-Silicium-Bindung
Argon bildet einige Clathrate in denen es physikalisch in Hohlräume eines umgebenden Kristalls eingeschlossen ist
Bei -<num> C ist ein Argon-Hydrat stabil jedoch ist die Geschwindigkeit der Bildung sehr langsam da eine Umkristallisierung stattfinden muss
Ist das Eis mit Chloroform gemischt bildet sich das Clathrat schon bei -<num> C Stabil ist auch ein Clathrat von Argon in Hydrochinon
Isotope
Insgesamt sind <num> Isotope sowie ein weiteres Kernisomer von Argon bekannt
Von diesen sind drei nämlich die Isotope <num>Ar <num>Ar und <num>Ar stabil und kommen in der Natur vor
Dabei überwiegt bei weitem <num>Ar mit einem Anteil von <num>
am natürlichen irdischen Isotopengemisch
<num>Ar und <num>Ar sind mit einem Anteil von <num>
beziehungsweise <num>
selten
Von den instabilen Isotopen besitzen <num>Ar mit <num> Jahren und <num>Ar mit <num> Jahren die längsten Halbwertszeiten
Alle anderen Isotope besitzen kurze Halbwertszeiten im Bereich von unter <num> ps bei <num>Ar bis <num> Tagen bei <num>Ar
<num>Ar wird für die Altersbestimmung von Gesteinen genutzt Kalium-Argon-Datierung
Dabei wird ausgenutzt dass instabiles <num>K das in diesen enthalten ist langsam zu <num>Ar zerfällt
Je mehr Kalium zu Argon zerfallen ist desto älter ist das Gestein Das kurzlebige Isotop <num>Ar kann zur Überprüfung von Gasleitungen verwendet werden
Durch das Durchleiten von <num>Ar kann die Leistungsfähigkeit einer Belüftung oder Dichtigkeit einer Leitung festgestellt werden
Liste der Argon-Isotope
Biologische Bedeutung
Wie die anderen Edelgase hat Argon auf Grund der Reaktionsträgheit keine biologische Bedeutung und ist auch nicht toxisch
In höheren Konzentrationen wirkt es durch Verdrängung des Sauerstoffs erstickend Bei Drücken von mehr als <num> bar wirkt es narkotisierend
Verwendung
DateiArgonjpg Als günstigstes und in großen Mengen verfügbares Edelgas wird Argon in vielen Bereichen verwendet
Die Produktion betrug <num> weltweit etwa <num> Milliarden m bzw <num> km Der größte Teil des Argons wird als Schutzgas verwendet
Es wird immer dann genutzt wenn der billigere Stickstoff nicht anwendbar ist
Dazu zählen vor allem Schweißverfahren für Metalle die mit Stickstoff bei hohen Temperaturen reagieren etwa Titan Tantal und Wolfram
Auch beim Metallinertgasschweißen und Wolfram-Inertgasschweißen die etwa beim Schweißen von Aluminiumlegierungen oder hoch legierten Stählen angewendet werden dient Argon als Inertgas
Weiterhin wird es in der Metallurgie als Schutzgas etwa für die Produktion von Titan hochreinem Silicium oder der Schmelzraffination sowie zum Entgasen von Metallschmelzen genutzt
Argon ist ein Lebensmittelzusatzstoff E <num> und dient als Treib- und Schutzgas bei der Verpackung von Lebensmitteln und der Weinherstellung
Argon wird als gasförmiges Löschmittel vorwiegend für den Objektschutz vor allem bei elektrischen und EDV-Anlagen eingesetzt und wirkt dabei durch Sauerstoffverdrängung
Für diesen Zweck wird reines Argon oder ein Gasgemisch zusammen mit Stickstoff verwendet
In der Analytik wird Argon als Träger- und Schutzgas für die Gaschromatographie und das induktiv gekoppelte Plasma ICP-MS ICP-OES verwendet
Glühlampen werden häufig mit Argon-Stickstoff-Gemischen gefüllt weil eine Gasfüllung die Sublimation des Glühfadens vermindert
Argon hat dabei eine geringere Wärmeleitfähigkeit als leichtere Gase ist aber preiswerter als andere schwerere und damit noch geringer wärmeleitende Gase wie Krypton oder Xenon
Ein Vorteil der geringeren Wärmeleitfähigkeit ist eine höhere mögliche Glühtemperatur und damit höhere Lichtausbeute
Ebenfalls wegen der geringen Wärmeleitfähigkeit wird es als Füllgas für Isolierglasscheiben verwendet
Auch in Gasentladungslampen dient Argon als Leuchtgas mit einer typischen violetten Farbe
Wird etwas Quecksilber dazugegeben ändert sich die Farbe ins Blaue
Weiterhin ist Argon das Lasermedium in Argon-Ionen-Lasern
Im Bereich der Stahlerzeugung kommt Argon eine besonders wichtige Rolle im Bereich der Sekundärmetallurgie zu
Mit der Argon-Spülung kann die Stahllegierung entgast und gleichzeitig homogenisiert werden speziell wird dabei der unerwünschte gelöste Stickstoff aus der Schmelze entfernt
Beim Tauchen wird Argon - insbesondere bei der Nutzung des Heliumhaltigen Trimix als Atemgas - dazu verwendet um Trockentauchanzüge zu füllen bzw damit zu tarieren
Hierbei wird ebenfalls die geringe Wärmeleitfähigkeit des Gases genutzt um das Auskühlen des Anzugträgers zu verzögern
Seit Mai <num> ist Argon auf der Dopingliste der Welt-Anti-Doping-Agentur WADA
Durch den bei der Inhalation von Argon entstehenden Sauerstoffmangel wird offensichtlich die Bildung von körpereigenem Erythropoetin EPO aktiviert
Aus demselben Grund ist auch Xenon auf der Dopingliste
Einzelnachweise
Literatur
P Häussinger R Glatthaar W Rhode H Kick C Benkmann J Weber H-J
Wunschel V Stenke E Leicht H Stenger Noble Gases In
Ullmanns Encyclopedia of Industrial Chemistry Wiley-VCH Weinheim <num> doi<num><num>a<num>_<num>
Weblinks
NA William H Brock Viewegs Geschichte der Chemie Vieweg Braunschweig <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> John Meurig Thomas Argon und das nichtinerte Paar Rayleigh und Ramsay In
Angew Chem
<num> <num> S <num>-<num> doi<num>ange<num>William Ramsay
The Rare Gases of the Atmosphere Nobelpreisrede <num> Dezember <num> Fritz Von Schröter Die Bedeutung der Edelgase für die Elektrotechnik In Naturwissenschaften <num> <num> <num> S <num>-<num> doi<num>BF<num> A G W Cameron Abundances of the elements in the solar system In Space Science Reviews <num> <num> S <num>-<num> PDF P R Mahaffy H B Niemann A Alpert S K Atreya J Demick T M Donahue D N Harpold T C Owen Noble gas abundance and isotope ratios in the atmosphere of Jupiter from the Galileo Probe Mass Spectrometer In J Geophys Res <num> <num> S <num>-<num> AbstractDavid R Williams
Earth Fact Sheet NASA Greenbelt Stand <num> Mai <num> Chris J Ballentine Geochemistry Earth holds its breath In
Nature <num> <num> S <num>-<num> doi<num><num>a P Häussinger R Glatthaar W Rhode H Kick C Benkmann J Weber H-J Wunschel V Stenke E Leicht H Stenger Noble Gases In
Ullmanns Encyclopedia of Industrial Chemistry Wiley-VCH Weinheim <num> doi<num><num>a<num>_<num> K Schubert Ein Modell für die Kristallstrukturen der chemischen Elemente In Acta Crystallographica Section B <num> <num> S <num>-<num> doi<num>S<num> A L Gosman R D McCarty J G Hust Thermodynamic Properties of Argon from the Triple Point to <num> K at Pressures to <num> Atmospheres In Nat Stand Ref Data Ser Nat Bur Stand <num> <num> NIST webbook Leonid Khriachtchev Mika Pettersson Nino Runeberg Jan Lundell Markku Räsänen A stable argon compound In Nature <num> <num> S <num>-<num> doi<num><num> Arik Cohen Jan Lundell R Benny Gerber First compounds with argon-carbon and argon-silicon chemical bonds In J Chem Phys <num> <num> S <num>-<num> doi<num><num> R M Barrer D J Ruzicka Non-stoichiometric clathrate compounds of water Part <num> - Kinetics of formation of clathrate phases In Transactions of the Faraday Society <num> <num> S <num>-<num> doi<num>TF<num> G Audi F G Kondev Meng Wang WJ Huang S Naimi The NUBASE<num> evaluation of nuclear properties In Chinese Physics C <num> <num> S <num>
Volltext Sicherheitsdatenblatt Argon PDF <num> kB Linde AG Stand <num> Juni <num> Walter J Moore Dieter O Hummel Physikalische Chemie <num> Auflage de Gruyter <num> ISBN <num>-<num>-<num>-<num> S <num> Zusatzstoff-Zulassungsverordnung
Jörg Niederstraßer
Kapitel <num>
PDF <num> kB Dissertation Universität Duisburg <num> Ausrüstung Argon
bei dir-mcom abgerufen am <num> August <num>
In Pharmazeutische Zeitung <num> Mai <num>
Arsen
ist ein chemisches Element mit dem Elementsymbol As und der Ordnungszahl <num> Im Periodensystem der Elemente steht es in der <num> Periode und der <num> Hauptgruppe bzw <num> IUPAC-Gruppe oder Stickstoffgruppe
Arsen kommt selten gediegen vor meistens in Form von Sulfiden
Es gehört zu den Halbmetallen da es je nach Modifikation metallische oder nichtmetallische Eigenschaften zeigt
Umgangssprachlich wird auch das als Mordgift bekannte Arsenik meist einfach Arsen genannt
Arsenverbindungen kennt man schon seit dem Altertum
Als mutagenes Klastogen können Arsenverbindungen als Gift wirken welches Chromosomenaberrationen hervorrufen und somit karzinogene Wirkung besitzen kann
Arsen wird zur Dotierung von Halbleitern und als Bestandteil von III-V-Halbleitern wie Galliumarsenid genutzt
Die organische Arsenverbindung Arsphenamin Salvarsan galt trotz schwerer und schwerster Nebenwirkungen Anfang des <num> Jahrhunderts als Durchbruch in der Behandlung der Syphilis
Heute wird Arsentrioxid als letzte Behandlungsoption in der Therapie der Promyelozytenleukämie angewendet
Geschichte
DateiAlbertusMagnusjpg Der Name Arsen geht unmittelbar auf
zurück der antiken Bezeichnung des Arsenminerals Auripigment
Sie findet sich schon bei Dioskurides im <num> Jahrhundert
Die griechische Bezeichnung scheint ihrerseits ihren Ursprung im Altpersischen al-zarnik goldfarben Auripigment Arsen zu haben und gelangte wohl durch semitische Vermittlung ins Griechische
Volksetymologisch wurde der Name fälschlicherweise vom gleichlautenden alt- und neu-griechischen Wort
abgeleitet das sich etwa mit männlichstark übersetzen lässt
Erst seit dem <num> Jahrhundert ist die Bezeichnung Arsen gebräuchlich
Das Elementsymbol wurde <num> von Jöns Jakob Berzelius vorgeschlagen
Der erste Kontakt von Menschen mit Arsen lässt sich aus dem <num> Jahrtausend v Chr nachweisen In den Haaren der im Gletschereis erhaltenen Mumie des volkstümlich Ötzi genannten Alpenbewohners ließen sich größere Mengen Arsen nachweisen was archäologisch als Hinweis darauf gedeutet wird dass der betroffene Mann in der Kupferverarbeitung tätig war - Kupfererze sind oft mit Arsen verunreinigt
Im klassischen Altertum war Arsen in Form der Arsen-Sulfide Auripigment As<num>S<num> und Realgar As<num>S<num> bekannt die etwa von dem Griechen Theophrastos dem Nachfolger Aristoteles beschrieben wurden
Auch der griechische Philosoph Demokrit hatte im <num> Jahrhundert v Chr nachweislich Kenntnisse über Arsenverbindungen
Der Leidener Papyrus X aus dem <num> Jahrhundert nach Chr lässt darauf schließen dass sie benutzt wurden um Silber goldartig und Kupfer weiß zu färben
Der römische Kaiser Caligula hatte angeblich bereits im <num> Jahrhundert nach Chr ein Projekt zur Herstellung von Gold aus dem goldgelben Auripigment in Auftrag gegeben
Die Alchimisten die Arsen-Verbindungen nachweislich der Erwähnung im antiken Standardwerk
Physica et Mystica
kannten vermuteten eine Verwandtschaft mit Schwefel und Quecksilber
ArsenIII-sulfid kam als Malerfarbe und Enthaarungsmittel zum Einsatz sowie zur äußerlichen als auch inneren Behandlung von Lungenkrankheiten
DateiArsenic alchemical symbolsvg Im Mittelalter wurde Arsenik ArsenIII-oxid im Hüttenrauch staubbeladenes Abgas metallurgischer Öfen gefunden
Albertus Magnus beschrieb um <num> erstmals die Herstellung von Arsen durch Reduktion von Arsenik mit Kohle
Er gilt daher als Entdecker des Elements auch wenn es Hinweise darauf gibt dass das elementare Metall schon früher hergestellt wurde
Paracelsus führte es im <num> Jahrhundert in die Heilkunde ein
Etwa zur gleichen Zeit wurden Arsenpräparate in der chinesischen Enzyklopädie
Pen-tsao Kang-mu
des Apothekers Li Shi-zhen beschrieben
Dieser Autor hebt insbesondere die Anwendung als Pestizid in Reisfeldern hervor
Im <num> Jahrhundert wurde das gelbe Auripigment bei holländischen Malern als
Königsgelb
populär
Da sich das Pigment über längere Zeiträume hinweg in ArsenIII-oxid umwandelt und von der Leinwand bröckelt entstehen Schwierigkeiten bei der Restaurierung
Ab <num> wurden Arsenpräparate in Europa mit Erfolg als Beizmittel im Pflanzenschutz eingesetzt
Diese Nutzung verbot man jedoch <num> wegen ihrer hohen Giftigkeit wieder
Der Einsatz von Arsenzusätzen für den Bleiguss beruht auf der größeren Härte solcher Bleilegierungen typische Anwendung sind Schrotkugeln
Obwohl die Giftigkeit und die Verwendung als Mordgift bekannt war ist Arsen im beginnenden <num> Jahrhundert eines der bedeutendsten Asthmamittel
Grundlage sind anscheinend Berichte in denen den Chinesen nachgesagt wurde sie würden Arsen in Kombination mit Tabak rauchen um Lungen zu bekommen die stark wie Blasebälge seien
Ebenfalls bis ins <num> Jahrhundert fanden Arsenverbindungen äußerlich und innerliche Anwendungen bei bösartigen Geschwülsten Hauterkrankungen und etwa in Form der Fowlerschen Tropfen bei Fieber
Arsen wurde in Form von Kupferarsenaten in Farbmitteln wie dem Pariser Grün eingesetzt um Tapeten zu bedrucken
Bei hoher Feuchtigkeit wurden diese Pigmente durch Schimmelpilzbefall in giftige flüchtige Arsenverbindungen umgewandelt die nicht selten zu chronischen Arsenvergiftungen führten
Doch auch in Kriegen fand Arsen Verwendung Im Ersten Weltkrieg wurden Arsenverbindungen in chemischen Kampfstoffen Blaukreuz oder Lewisit eingesetzt
Bei den Opfern bewirkten sie durch Angriff auf Haut und Lungen grausame Schmerzen und schwerste körperliche Schädigungen
Vorkommen
DateiArsen gediegen - St Andreasberg HarzJPG DateiArsenic-<num>jg<num>ajpg Arsen kommt in geringen Konzentrationen von bis zu <num> ppm praktisch überall im Boden vor
Es ist in der Erdkruste ungefähr so häufig wie Uran oder Germanium
In der kontinentalen Erdkruste kommt Arsen mit durchschnittlich <num> ppm vor wobei es durch seinen lithophilen Charakter
Silikat liebend in der oberen Kruste angereichert ist <num> ppm gegenüber <num> ppm in der unteren Kruste damit liegt Arsen in der Tabelle der häufigsten Elemente an <num> Stelle
Arsen Scherbenkobalt kommt in der Natur gediegen das heißt in elementarer Form vor und ist daher von der International Mineralogical Association IMA als eigenständiges Mineral anerkannt
Gemäß der Systematik der Minerale nach Strunz <num> Auflage wird Arsen unter der System-Nr
<num>CA<num> Elemente - Halbmetalle Metalloide und Nichtmetalle - Arsengruppen-Elemente <num> Auflage IB<num>-<num> eingeordnet
Die im englischsprachigen Raum ebenfalls geläufige Systematik der Minerale nach Dana führt das Element-Mineral unter der System-Nr
<num><num>
Weltweit sind zurzeit Stand <num> rund <num> Fundorte für gediegenes Arsen bekannt In Deutschland wurde es an mehreren Fundstätten im Schwarzwald Baden-Württemberg im bayerischen Spessart und Oberpfälzer Wald im hessischen Odenwald in den Silberlagerstätten des Westerzgebirges Sachsen am Hunsrück Rheinland-Pfalz sowie im Thüringer Wald gefunden
In Österreich trat Arsen an mehreren Fundstätten in Kärnten Salzburg und der Steiermark zutage
In der Schweiz fand sich gediegen Arsen in den Kantonen Aargau und Wallis
Weitere Fundorte sind in Australien Belgien Bolivien Bulgarien Chile China Finnland Frankreich Griechenland Irland Italien Japan Kanada Kasachstan Kirgisistan Madagaskar Malaysia Marokko Mexiko Mongolei Neuseeland Norwegen Österreich Peru Polen Rumänien Russland Schweden Slowakei Spanien Tschechien Ukraine Ungarn im Vereinigten Königreich Großbritannien und in den Vereinigten Staaten USA bekannt
Weit häufiger kommt das Element allerdings in verschiedenen intermetallischen Verbindungen mit Antimon Allemontit und Kupfer Whitneyit sowie in verschiedenen Mineralen vor die überwiegend der Klasse der Sulfide und Sulfosalze angehören
Insgesamt sind bisher Stand <num> <num> Arsenminerale bekannt Die höchsten Konzentrationen an Arsen enthalten dabei unter anderem die Minerale Duranusit ca <num>
Skutterudit und Arsenolith jeweils ca <num>
die allerdings selten zu finden sind
Weit verbreitet sind dagegen Arsenopyrit Arsenkies Löllingit Realgar Rauschrot und Auripigment Orpiment Rauschgelb
Weitere bekannte Minerale sind Cobaltit Kobaltglanz Domeykit Arsenkupfer Enargit Gersdorffit Nickelarsenkies Proustit Lichtes Rotgültigerz Rubinblende Rammelsbergit sowie Safflorit und Sperrylith
Arsenate finden sich häufig in phosphathaltigen Gesteinen da sie eine vergleichbare Löslichkeit aufweisen und das häufigste Sulfidmineral Pyrit kann bis zu einigen Massenprozent Arsen einbauen
Arsen wird heutzutage als Nebenprodukt der Verhüttung von Gold- Silber- Zinn- Kupfer- Cobalt- und weiteren Buntmetallerzen sowie bei der Verarbeitung von Phosphatrohstoffen gewonnen
Die größten Produzenten im Jahr <num> waren China Chile Marokko und Peru
Arsen ist nur schwer wasserlöslich und findet sich daher nur in geringen Spuren etwa <num> ppb Milliardstel Massenanteilen in Meeren und Ozeanen
In der Luft findet man Arsen in Form von partikulärem ArsenIII-oxid
Als natürliche Ursache dafür hat man Vulkanausbrüche identifiziert die insgesamt jährlich geschätzte <num> Tonnen in die Erdatmosphäre eintragen
Bakterien setzen weitere <num> Tonnen in Form organischer Arsenverbindungen wie Trimethylarsin frei
Ein großer Teil am freigesetzten Arsen entstammt der Verbrennung fossiler Brennstoffe wie Kohle oder Erdöl
Die geschätzten Emissionen verursacht durch den Straßenverkehr und stationäre Quellen betrugen <num> in der Bundesrepublik Deutschland <num> Tonnen <num> Tonnen in den alten <num> Tonnen in den neuen Bundesländern
Die Außenluftkonzentration von Arsen liegt zwischen <num> und <num> Nanogramm pro Kubikmeter
Gewinnung und Darstellung
DateiArsenbergwerkRotgueldenseejpg
Arsen fällt in größeren Mengen als Nebenprodukt bei der Gewinnung von Kupfer Blei Cobalt und Gold an
Dies ist die Hauptquelle für die kommerzielle Nutzung des Elements
Es kann durch thermische Reduktion von ArsenIII-oxid mit Koks oder Eisen und durch Erhitzen von Arsenkies FeAsS oder Arsenikalkies FeAs<num> unter Luftabschluss in liegenden Tonröhren gewonnen werden
Dabei sublimiert elementares Arsen das an kalten Oberflächen wieder in den festen Aggregatzustand zurückkehrt
FeAsS_s -> FeS_s
As_g
Arsenkies zersetzt sich in Eisensulfid und elementares Arsen
FeAs<num>_s -> FeAs_s
As_g
Arsenikalkies zersetzt sich in Eisenarsenid und elementares Arsen
Für die Halbleitertechnik wird Arsen dessen Reinheit über <num> Prozent betragen muss durch Reduktion von mehrfach destilliertem ArsenIII-chlorid im Wasserstoffstrom hergestellt
<num>AsCl<num>
<num>H<num> -> <num>HCl
<num>As
Arsentrichlorid reagiert mit Wasserstoff zu Chlorwasserstoff und elementarem Arsen
Früher wurde es auch durch Sublimation aus Lösungen in flüssigem Blei erzeugt
Dabei wird der Schwefel der Arsen-Erze durch das Blei in Form von BleiII-sulfid gebunden
Die hierbei erzielten Reinheiten von über <num> Prozent waren für Halbleiteranwendungen nicht ausreichend
Eine andere Möglichkeit besteht im Auskristallisieren bei hohen Temperaturen aus geschmolzenem Arsen oder in der Umwandlung in Monoarsan einer anschließenden Reinigung sowie der Zersetzung bei <num> C in Arsen und Wasserstoff
Eigenschaften
DateiArsenkomplexepng DateiArsen <num>jpg Arsen bildet mit Stickstoff Phosphor Antimon und Bismut die <num> Hauptgruppe des Periodensystems und nimmt wegen seiner physikalischen und chemischen Eigenschaften den Mittelplatz in dieser Elementgruppe ein
Arsen hat eine relative Atommasse von <num>
Der Radius des Arsen-Atoms beträgt <num> Pikometer
In kovalent gebundenem Zustand ist er etwas kleiner <num> Pikometer
Aufgrund der Abgabe der äußeren Elektronen Valenzelektronen bei der Ionisierung reduziert sich der Radius beträchtlich auf <num> Pikometer As<num> das äußerste p- und das äußerste s-Atomorbital bleiben unbesetzt beziehungsweise <num> Pikometer As<num> nur das p-Orbital ist unbesetzt
In chemischen Komplexverbindungen ist das As<num>-Kation von vier Bindungspartnern Liganden As<num> von sechs umgeben
Arsen tritt allerdings nur sehr selten in eindeutig ionischer Form auf
Der Wert für die Elektronegativität liegt nach Pauling auf der von <num> Metalle bis <num> Nichtmetall reichenden Skala bei <num> und ist damit mit dem Wert des Gruppennachbarn Phosphor vergleichbar
Der Halbmetall-Charakter des Arsens zeigt sich zudem darin dass die benötigte Dissoziationsenergie von <num> kJmol also die Energie die aufgebracht werden muss um ein einzelnes Arsen-Atom aus einem Arsen-Festkörper herauszulösen zwischen der des Nichtmetalls Stickstoff <num> kJmol kovalente Bindung und des Metalls Bismut <num> kJmol metallische Bindung liegt
Unter Normaldruck sublimiert Arsen bei einer Temperatur von <num> C geht also aus dem festen Aggregatzustand direkt in die Gasphase über
Arsendampf ist zitronengelb und setzt sich bis ungefähr <num> C aus As<num>-Molekülen zusammen
Oberhalb von <num> C liegen As<num>-Moleküle vor
Arsen zeigt je nach Verbindungspartner Oxidationsstufen zwischen -<num> und <num>
Mit elektropositiven Elementen wie Wasserstoff oder Metallen bildet es Verbindungen in denen es eine Oxidationsstufe von -<num> einnimmt
Beispiele dafür sind Monoarsan AsH<num> und Arsenkupfer Cu<num>As
In Verbindungen mit elektronegativen Elementen wie den Nichtmetallen Sauerstoff Schwefel und Chlor besitzt es die Oxidationsstufe <num> oder <num> erstere ist dabei gegenüber den in derselben Hauptgruppe stehenden Elementen Stickstoff und Phosphor tendenziell bevorzugt
Modifikationen
Arsen kommt wie andere Elemente der Stickstoffgruppe in verschiedenen allotropen Modifikationen vor
Anders als beim Stickstoff der in Form zweiatomiger Moleküle mit kovalenter Dreifachbindung vorkommt sind die entsprechenden As<num>-Moleküle instabil und Arsen bildet stattdessen kovalente Netzwerke aus
Graues Arsen
DateiGrauesarsenpng Graues oder metallisches Arsen ist die stabilste Form Es hat eine Dichte von <num> gcm<num>
Seine Kristalle sind stahlgrau metallisch glänzend und leiten den elektrischen Strom
Betrachtet man den strukturellen Aufbau des grauen Arsens dann erkennt man Schichten aus gewellten Arsen-Sechsringen welche die Sesselkonformation einnehmen
Darin bilden die Arsen-Atome eine Doppelschicht wenn man sich den Aufbau der Schicht im Querschnitt ansieht
Die Übereinanderlagerung dieser Doppelschichten ist sehr kompakt
Bestimmte Atome der nächsten darüberliegenden oder darunterliegenden Schicht sind von einem Bezugsatom fast ähnlich weit entfernt wie innerhalb der betrachteten Doppelschicht
Dieser Aufbau bewirkt dass die graue Arsen-Modifikation wie die homologen Elemente Antimon und Bismut sehr spröde ist
Deswegen werden diese drei Elemente häufig auch als Sprödmetalle bezeichnet
Gelbes Arsen
Wird Arsen-Dampf in dem Arsen gewöhnlich als As<num>-Tetraeder vorliegt schnell abgekühlt so bildet sich das metastabile gelbe Arsen mit einer Dichte von <num> gcm<num>
Es besteht ebenfalls aus tetraedrischen As<num>-Molekülen
Gelbes Arsen ist ein Nichtmetall und leitet infolgedessen den elektrischen Strom nicht
Es kristallisiert aus Schwefelkohlenstoff und bildet kubische stark lichtbrechende Kristalle die nach Knoblauch riechen
Bei Raumtemperatur und besonders schnell unter Lichteinwirkung wandelt sich gelbes Arsen in graues Arsen um
Schwarzes Arsen
Schwarzes Arsen selbst kann seinerseits in zwei verschiedenen Formen vorkommen
Amorphes schwarzes Arsen entsteht durch Abkühlung von Arsen-Dampf an <num> bis <num> C warmen Oberflächen
Es besitzt keine geordnete Struktur sondern liegt in einer amorphen glasartigen Form vor analog zum roten Phosphor
Die Dichte beträgt <num> bis <num> gcm<num>
Oberhalb <num> C wandelt sich das schwarze Arsen in die graue Modifikation um
Wird glasartiges amorphes schwarzes Arsen bei Anwesenheit von metallischem Quecksilber auf <num> bis <num> C erhitzt so entsteht das metastabile
orthorhombische schwarze Arsen das mit dem schwarzen Phosphor vergleichbar ist
Natürlich gebildetes orthorhombisches schwarzes Arsen ist in der Natur als seltenes Mineral Arsenolamprit bekannt
Braunes Arsen
Bei der Reduktion von Arsenverbindungen in wässriger Lösung entstehen ähnlich wie beim Phosphor Mischpolymerisate
Bei diesen bindet ein Teil der freien Valenzen des Arsens Hydroxygruppen -OH
Man nennt diese Form des Arsens braunes Arsen
Reaktionen
Arsen reagiert heftig mit Oxidationsmitteln und Halogenen
So verbrennt Arsen an der Luft mit bläulicher Flamme zu einem weißen Rauch von giftigem ArsenIII-oxid
<num>As
<num>O<num> -> <num>As<num>O<num>
Arsen reagiert mit Sauerstoff zu ArsenIII-oxid
Ohne äußere Wärmezufuhr findet die Reaktion mit Chlor unter Feuererscheinung zu ArsenIII-chlorid statt
<num>As
<num>Cl<num> -> <num>AsCl<num>
Arsen reagiert mit Chlor zu Arsentrichlorid
Eine weitere Oxidation ist möglich
AsCl<num>
Cl<num> -> AsCl<num>
Arsentrichlorid reagiert mit Chlor zu Arsenpentachlorid
Analoge Reaktionsgleichungen gelten für die entsprechenden Reaktionen mit Fluor
Stark oxidierende Säuren wie konzentrierte Salpetersäure oder Königswasser wandeln Arsen in Arsensäure um
As
<num>HNO<num> -> <num>NO<num>
H<num>O
H<num>AsO<num>
Arsen reagiert mit Salpetersäure zu Stickstoffdioxid Wasser und Arsensäure
Ist die Oxidationsstärke weniger groß - etwa bei Verwendung von verdünnter Salpetersäure oder Schwefelsäure - entsteht Arsenige Säure
<num>As
<num>H<num>SO<num> -> <num>SO<num>
<num>H<num>AsO<num>
Arsen reagiert mit Schwefelsäure zu Schwefeldioxid und Arseniger Säure
Unter sauren Bedingungen und bei Anwesenheit von nichtpassivierten unedlen Metallen insbesondere Zink reagiert Arsen mit dem gebildeten Wasserstoff zu Monoarsan
Zn
<num>H<num>O -> Zn<num>
H<num>
<num> H<num>O
Zink reagiert mit Wasserstoffionen zu Zinkionen und neutralem Wasserstoff
<num>As
<num>H<num> -> <num>AsH<num>
Arsen reagiert mit Wasserstoff zu Monoarsan
Mit basischem Natriumhydroxid bildet sich das entsprechende Arsenitsalz
<num>As
<num>NaOH -> <num>Na<num>AsO<num>
<num>H<num>
Arsen reagiert mit Natriumhydroxid zu Natriumarsenit und elementarem Wasserstoff
Isotope
Vom Arsen sind künstlich hergestellte radioaktive Isotope mit Massenzahlen zwischen <num> und <num> bekannt
Die Halbwertszeiten liegen zwischen <num> Millisekunden <num>As und <num> Tagen <num>As
Natürlich vorkommendes Arsen besteht zu <num> Prozent aus dem Isotop <num>As es ist daher ein anisotopes Element
Der entsprechende Arsen-Kern besteht also aus genau <num> Protonen und <num> Neutronen
Physikalisch zählt man ihn daher zu den ug-Kernen u steht hier für ungerade g für gerade
Sein Kernspin beträgt <num><num>
Verwendung
Arsen wird Bleilegierungen zugesetzt um ihre Festigkeit zu verbessern und das Blei gießbar zu machen
Vor allem die fein strukturierten Platten von Akkumulatoren könnten ohne Arsen nicht gegossen werden
Historisch war Arsen eine wichtige Zutat von Kupferlegierungen die dadurch besser verarbeitbar wurden
Metallisches Arsen wurde früher gelegentlich zur Erzeugung mattgrauer Oberflächen auf Metallteilen verwendet um eine Alterung vorzutäuschen
DateiWafer <num> Zoll bis <num> Zolljpg In der Elektronik spielt es als mindestens <num> Prozent reines Element für Gallium-Arsenid-Halbleiter sogenannte III-V-Halbleiter aufgrund der Kombination von Elementen aus der <num> und <num> Hauptgruppe des Periodensystems sowie für Epitaxieschichten auf Wafern in Form von Indiumarsenidphosphid und Galliumarsenidphosphid eine wesentliche Rolle in der Herstellung von Hochfrequenzbauelementen wie Integrierten Schaltkreisen ICs Leuchtdioden LEDs beziehungsweise Laserdioden LDs
Es gab Anfang <num> weltweit nur drei Hersteller von hochreinem Arsen zwei in Deutschland und einen in Japan
Arsen wird in Form seiner Verbindungen in einigen Ländern als Schädlingsbekämpfungsmittel im Weinbau als Fungizid Antipilzmittel in der Holzwirtschaft als Holzschutzmittel als Rattengift und als Entfärbungsmittel in der Glasherstellung verwendet
Der Einsatz ist umstritten da die eingesetzten Arsenverbindungen hauptsächlich ArsenIII-oxid giftig sind
Arsen in Arzneimitteln
Die Verwendung arsenhaltiger Mineralien als Heilmittel ist bereits in der Antike durch Hippokrates und Plinius bezeugt
Sie wurden als Fiebermittel als Stärkungsmittel und zur Therapie von Migräne Rheumatismus Malaria Tuberkulose und Diabetes eingesetzt
Im <num> Jahrhundert wurde eine Mischung aus Kaliumarsenit und Lavendelwasser als Fowlersche Lösung bekannt die lange als medizinisches Wundermittel galt und als Fiebersenker Heilwasser und sogar als Aphrodisiakum Anwendung fand
Kaliumarsenit war als Bestandteil der Fowlerschen Lösung bis in die <num>er Jahre in Deutschland als Mittel zur Behandlung der Psoriasis im Einsatz
Constantinus Africanus <num>-<num> empfahl eine Arsenapplikation zur Bekämpfung von Zahnschmerzen
Bereits um <num> vor Christus soll die Anwendung von Arsen zur Behandlung eines schmerzenden Zahnes in der chinesischen Heilkunst beschrieben worden sein
In dem Mitte des <num> Jahrhunderts erschienenen Werk Liber Regius empfahl der arabische Arzt Haly Abbas ʿAli ibn al-ʿAbbās
<num> ebenfalls den Einsatz von Arsenik zur Devitalisation der Pulpa ArsenIII-oxid wurde bis in die Neuzeit zur Devitalisation der Zahnpulpa verwendet und verschwand in den <num>er Jahren wegen der krebserregenden Wirkung Entzündungen des Zahnhalteapparates des Verlustes eines oder mehrerer Zähne einschließlich Nekrosen des umliegenden Alveolarknochens Allergien und Vergiftungserscheinungen aus dem Therapiespektrum
Einen Aufschwung erlebten arsenhaltige bzw Arsenverbindungen enthaltende Arzneimittel zu Beginn des <num> Jahrhunderts
Harold Wolferstan Thomas und Anton Breinl konnten <num> beobachten dass das arsenhaltige Präparat Atoxyl Trypanosomen zu denen die Erreger der Schlafkrankheit gehören abtötet
<num> wurde eine Weiterentwicklung das Tryparsamid in der Zeit von <num> bis <num> im tropischen Afrika zur Therapie der Schlafkrankheit eingesetzt
Es war bedeutsam für die Eingrenzung dieser Epidemie in der ersten Hälfte des vorigen Jahrhunderts konnte jedoch zur Erblindung führen
Das in den <num>er Jahren entwickelte Melarsoprol war über mehrere Jahrzehnte das Mittel der Wahl zur Behandlung der Schlafkrankheit und wird heute noch eingesetzt da keine effektiven Nachfolgepräparate zur Verfügung stehen
Ebenfalls angeregt durch die Trypanosomen-toxische Wirkung von Atoxyl entwickelte Paul Ehrlich das arsenhaltige Arsphenamin Salvarsan Das <num> in die Therapie der Syphilis eingeführte Mittel stellte das erste auf theoretischen Vorüberlegungen beruhende systematisch entwickelte spezifisch wirkende Chemotherapeutikum dar und war Vorbild für die Entwicklung der bis heute verwendeten Sulfonamide
Es wurde lange Zeit auch bei der Behandlung von Dysenterie eingesetzt
Im Jahr <num> wurde ein arsenikhaltiges Präparat unter dem Namen Trisenox in den USA zur Behandlung der akuten Promyelozytenleukämie APL zugelassen
Seit <num> besteht für Trisenox in Europa eine Zulassung zur Behandlung der APL Vertrieb in EU und USA Cephalon
Seine Wirksamkeit bei der Krebstherapie wird auch auf die antiangioneogenetische Wirkung zurückgeführt
Die verschiedenen Arsensulfide sind Bestandteil von Arzneimitteln der Chinesischen Medizin
Arsenik als Insektizid bei der Taxidermie
Aufgrund der toxischen Eigenschaften von Arsenverbindungen wurde früher überwiegend Arsenik
zur Haltbarmachung von Wirbeltieren Taxidermie als Insektizid verwendet Viele andere Stoffe wie auch Lindan wurden zum selben Zweck verwendet wie es die Fachliteratur der Präparatoren aus der Zeit von <num> bis <num> beschreibt
Solche Stoffe sind jedoch auch für Menschen giftig und stellen heute an Präparatoren besondere Anforderungen da diese auch in Kontakt mit derart kontaminierten Präparaten kommen
Biologische Bedeutung
Die biologische Bedeutung des Arsens für den Menschen ist nicht vollständig geklärt
Es gilt als Spurenelement im Menschen Mangelerscheinungen wurden bisher aber nur an Tieren nachgewiesen
Der notwendige Bedarf liegt falls er bestehen sollte zwischen <num> und <num> µg pro Tag Eine tägliche Arsenaufnahme von - je nach Wahl der Nahrungsmittel - bis zu einem Milligramm gilt als harmlos
In einer neuen Studie konnte eine erhöhte Arsenbelastung durch hohe Arsengehalte im Grundwasser von Reisanbaugebieten mit der Entstehung von Krebserkrankungen in Verbindung gebracht werden
Die Förderung der Krebsentwicklung ist jedoch dosisabhängig und nur bei Verzehr von belastetem Reis als täglichem Grundnahrungsmittel gegeben Es gibt bei regelmäßigem Verzehr von Arsenverbindungen speziell Arsentrioxid eine Gewöhnung die beim Absetzen der Dosis sogar von Entzugserscheinungen begleitet werden
Menschen die eine solche Gewöhnung erworben haben werden Arsenikesser genannt
Meerestiere wie Muscheln oder Garnelen enthalten besonders viel Arsen letztere bis zu <num> ppm
Vermutlich agiert es durch die Bindung an freie Thiolgruppen in Enzymen als Inhibitor verhindert also deren Wirkung
Für viele Tiere ist Arsen ein essentielles Spurenelement
So zeigen Hühner oder Ratten bei arsenfreier Ernährung deutliche Wachstumsstörungen dies hängt wahrscheinlich mit dem Einfluss des Elements auf die Verstoffwechslung der Aminosäure Arginin zusammen
Zahlreiche Algen und Krebstiere enthalten organische Arsen-Verbindungen wie das schon erwähnte Arsenobetain
Arsen führt zur verstärkten Bildung der sauerstofftransportierenden roten Blutkörperchen
Aus diesem Grund wurde es früher dem Futter von Geflügel und Schweinen zugesetzt um eine schnellere Mästung zu ermöglichen
Trainer von Rennpferden benutzten es zum illegalen Doping ihrer Tiere - heute kann der Zusatz von Arsen zur Nahrung allerdings leicht im Urin nachgewiesen werden
Lösliche Arsenverbindungen werden leicht über den Magen-Darm-Trakt aufgenommen und rasch innerhalb von <num> Stunden im Körper verteilt
Man findet den größten Teil des aufgenommenen Arsens in den Muskeln Knochen Nieren und Lungen
Im Menschen wurde es zusammen mit Thallium in fast jedem Organ nachgewiesen
Blut enthält bis zu <num> ppb Arsen in den anderen Organen des Körpers wie etwa den Knochen hat es einen Anteil von zwischen <num> und <num> ppm in Haaren liegt der Anteil bei etwa <num> ppm
Der Gesamtgehalt von Arsen im Körper eines Erwachsenen liegt im Durchschnitt bei etwa <num> Milligramm
Organische Arsenverbindungen wie die aus Fischen und Meeresfrüchten stammende Dimethylarsinsäure Trimethylarsenoxid Trimethylarsin sowie Arsenobetain verlassen den menschlichen Körper fast unverändert innerhalb von zwei bis drei Tagen über die Nieren
Anorganische Arsenverbindungen werden in der Leber zu Monomethylarsonsäure MMAA und Dimethylarsinsäure DMAA umgewandelt und anschließend ebenso über die Nieren ausgeschieden
Bei Pflanzen erhöht das Element den Kohlenhydrat-Umsatz
Der Gebänderte Saumfarn Pteris vittata nimmt das Halbmetall bevorzugt aus dem Boden auf und kann bis zu fünf Prozent seines Trockengewichts an Arsen aufnehmen
Aus diesem Grund wird die schnellwachsende Pflanze zur biologischen Säuberung arsenkontaminierter Böden eingesetzt
Die stimulierende Wirkung des Arsens ist vermutlich auch Ursache des früher in einigen Alpengegenden verbreiteten Arsenikessens
Im <num> Jahrhundert verzehrten manche der dortigen Bewohner lebenslang zweimal wöchentlich bis zu <num> Milligramm Arsen - bei Männern weil es bei der Arbeit in den Höhenlagen half bei Frauen da es angeblich zu einer kräftigen Gesichtsfarbe beitrug
In der Wissenschaft lange als Märchen abgetan nahm ein Bauer aus den Steirischen Alpen <num> vor der in Graz versammelten deutschen Fachwelt eine Dosis von <num> Milligramm Arsentrioxid zu sich die sich später auch in seinem Urin nachweisen ließ
Die Dosis lag weit über dem Doppelten der für normale Menschen tödlichen Arsenmenge zeigte aber keinerlei negative Auswirkungen auf den Bauern
Ähnliches wird von Bewohnern einer Siedlung in der hochgelegenen chilenischen Atacamawüste berichtet deren Trinkwasser hochgradig mit Arsen belastet ist die jedoch keinerlei Vergiftungssymptome zeigen
Heute geht man davon aus dass eine langsame Gewöhnung an das Gift mit sukzessive steigenden Dosen physiologisch möglich ist
Über den Bakterienstamm GFAJ-<num> wurde <num> berichtet dass er unter bestimmten Bedingungen in arsenathaltigen Nährmedien in der Lage sei Arsenat anstatt Phosphat in Biomoleküle wie die DNA einzubauen ohne dabei abzusterben was bisher eher als unmöglich galt Der Befund scheint jedoch auf unsauberen Arbeitsmethoden zu basieren
die Befunde konnten nicht repliziert werden
Sicherheitshinweise
Arsen-Stäube sind leicht entzündlich
Toxizität
Dreiwertige lösliche Verbindungen des Arsens sind hoch toxisch weil sie biochemische Prozesse wie die DNA-Reparatur den zellulären Energiestoffwechsel rezeptorvermittelte Transportvorgänge und die Signaltransduktion stören
Dabei kommt es mutmaßlich nicht zu einer direkten Einwirkung auf die DNA sondern zu einer Verdrängung des Zink-Ions aus seiner Bindung zu Metallothioneinen und damit zur Inaktivierung von Tumor-Repressor-Proteinen siehe auch Zinkfingerprotein
ArsenIII- und ZinkII-Ionen haben vergleichbare Ionenradien und damit ähnliche Affinität zu diesen Zink-Finger-Proteinen allerdings führt Arsen dann nicht zur Aktivierung der Tumor-Repressor-Proteine
Eine akute Arsenvergiftung führt zu Krämpfen Übelkeit Erbrechen inneren Blutungen Durchfall und Koliken bis hin zu Nieren- und Kreislaufversagen
Bei schweren Vergiftungen fühlt sich die Haut feucht und kalt an und der Betroffene kann in ein Koma fallen
Die Einnahme von <num> bis <num> Milligramm Arsenik gilt für Menschen als tödliche Dosis LD<sub><num><sub>
<num> mgkg Körpergewicht meist tritt der Tod innerhalb von mehreren Stunden bis wenigen Tagen durch Nieren- und Herz-Kreislauf-Versagen ein
Eine chronische Arsenbelastung kann Krankheiten der Haut und Schäden an den Blutgefäßen hervorrufen was zum Absterben der betroffenen Regionen Black Foot Disease sowie zu bösartigen Tumoren der Haut Lunge Leber und Harnblase führt
Diese Symptome wurden auch als Reichensteiner Krankheit bezeichnet nach einem Ort in Schlesien dessen Trinkwasser durch den Arsenik-Abbau bis zu <num> mg Arsen pro Liter enthielt
Die chronische Arsen-Vergiftung führt über die Bindung an Sulfhydryl-Gruppen von Enzymen der Blutbildung zum Beispiel Delta-Amino-Laevulin-Säure-Synthetase zu einem initialen Abfall des Hämoglobins im Blut was zu einer reaktiven Polyglobulie führt
Des Weiteren kommt es bei chronischer Einnahme von Arsen zur Substitution der Phosphor-Atome im Adenosin-Triphosphat ATP und damit zu einer Entkopplung der Atmungskette was zu einer weiteren reaktiven Polyglobulie führt
Klinisch finden sich hier nach Jahren der As-Exposition Trommelschlägelfinger Uhrglasnägel Mees-Nagelbänder und Akrozyanose Raynaud-Syndrom mit Folge der Black Foot Disease
Metallisches Arsen dagegen zeigt wegen seiner Unlöslichkeit nur eine geringe Giftigkeit da es vom Körper kaum aufgenommen wird LD<num>
<num> mgkg Ratte oral Es sollte aber da es sich an der Luft leicht mit seinen sehr giftigen Oxiden wie dem Arsenik überzieht stets mit größter Vorsicht behandelt werden
Anders verhält es sich mit Arsenik das in früheren Zeiten als Stimulans von Arsenikessern benutzt wurde um einer Arsenvergiftung vorzubeugen
Der Mechanismus dieser Immunisierung gegen Arsen ist nicht bekannt
Grenzwerte
Anionisches Arsen tritt als Arsenit AsO<num><num>- und Arsenat AsO<num><num>- in vielen Ländern im Grundwasser in hohen Konzentrationen auf
Durch Auswaschungen aus arsenhaltigen Erzen in Form von drei- und fünfwertigen Ionen trinken weltweit über <num> Millionen Menschen belastetes Wasser
Besonders in Indien Bangladesh und Thailand wo im <num> Jahrhundert mit internationaler Unterstützung zahlreiche Brunnen gegraben wurden um von mit Krankheitserregern kontaminiertem Oberflächenwasser auf Grundwasser ausweichen zu können führte diese unerkannte Belastung des Trinkwassers zu chronischer Arsenvergiftung bei weiten Teilen der betroffenen Bevölkerung
Das Problem kann wo es bekannt wird chemisch durch Oxidation der Arsenverbindungen und nachfolgende Ausfällung mit Eisenionen behoben werden
Von der Rice University wurde eine kostengünstige Filtermöglichkeit mit Nano-Magnetit entwickelt DateiWeltkarte arsenrisikogebietegif Die Weltgesundheitsorganisation WHO empfiehlt seit <num> einen Grenzwert für Arsen im Trinkwasser von <num> Mikrogramm pro Liter
Der Wert wird in vielen Staaten Europas und in den USA immer noch überschritten
In Deutschland wird er dagegen seit <num> eingehalten
Eine Richtlinie der Europäischen Union EU von <num> schreibt einen Höchstwert von <num> Mikrogramm pro Liter Trinkwasser EU-weit vor Die USA verpflichteten sich im Jahre <num> diesen Grenzwert ab <num> einzuhalten
Das im Grundwasser vorkommende Arsen reichert sich in Reis zehnmal so stark an wie in anderen Getreidearten
Auf dem Weltmarkt angebotene Sorten enthalten zwischen <num> und <num> Mikrogramm Arsen pro Kilogramm
Im Jahr <num> senkte die chinesische Regierung den zulässigen Gehalt anorganischer Arsenverbindungen von <num> auf <num> Mikrogramm pro Kilogramm Lebensmittel im Juli <num> beschloss die Codex Alimentarius-Kommission erstmals einen Höchstwert von <num> Mikrogramm für polierten Reis
Die für Lebensmittelsicherheit zuständige EU-Kommission diskutiert für Erzeugnisse aus Puffreis einen um <num> Prozent höheren Grenzwert und für spezielle Produkte für Kleinkinder einen nur halb so hohen d h
<num> Mikrogramm pro kg
Für andere belastete Lebensmittel wie Bier
oder Fruchtsäfte gibt es noch keine Grenzwerte obwohl sie mehr Arsen enthalten können als für Trinkwasser zulässig ist
Verbraucherorganisationen fordern für Apfelsaft einen Grenzwert von <num> höchstens aber <num> ppb entspricht Mikrogramm pro kg
Fische und Meeresfrüchte weisen zwar hohe Gehalte an Arsen auf jedoch nahezu ausschließlich in der als unbedenklich geltenden organisch gebundenen Form Grenzwerte wie für Quecksilber oder Cadmium gibt es nicht
Das neue Chemikaliengesetz der EU umgesetzt in der Gefahrstoffverordnung Deutschlands von <num> verbietet im Anhang <num> die gewerbliche nicht private Verarbeitung von arsenhaltigen Mitteln und Zubereitungen die mehr als <num> Gewichtsprozent an Arsen aufweisen
Derartige Grenzwertregelungen sind gegeben da Arsen in den Verzinkereien der Galvanikindustrie weltweit der Zinkschmelze zugesetzt wird um die Haftungseigenschaften des Zinks an der Eisenoberfläche des zu verzinkenden Metallstückes zu verbessern
Auf Grund der Temperatur im Zink-Schmelzbad von <num> C bis <num> C kommt es zum Verdampfen von Arsen Cadmium und anderen leicht flüchtigen Metallen und deren Anreicherung in der Luft des Arbeitsplatzes
So können zulässige Grenzwerte kurzfristig um das Tausendfache überschritten werden mit der Folge der aerogen-alveolaren Aufnahme in den Körper Messungen ergaben dass Arsen und Cadmium im hochreinen Zink <num> Reinheitsgrad DIN-<num>-Reinheitsgrad mit weniger als <num> Gewichts- ausgewiesen waren und nach Zugabe von <num> Gramm dieses hochreinen Zinks in die Zinkschmelze zu einem Anstieg der Cd-As-Konzentration von <num> bis <num> µgm<num> Luft auf über <num> µgm<num> Luft führten
Für Arsen wurde diese Tatsache überraschend in einer Verzinkerei durch Messung der Arsen-Konzentration in Zinkschmelze Blut und Urin festgestellt unveröffentlicht
Bei Galvanik-Arbeitern wird die Urin-Arsen-Konzentration mit <num> bis <num> µgl Urin gemessen im Vergleich zu unbelasteter Bevölkerung mit <num> µg Arsenl Urin
Abreicherung
Für die Entfernung von ionischem Arsen aus dem Trinkwasser gibt es Verfahren die auf Adsorption an Aktivkohle aktiviertem Aluminiumoxid oder Eisenhydroxid-Granulat beruhen
Daneben werden Ionenaustauscher verwendet
Es ist möglich Arsen mittels gentechnisch veränderten Pflanzen aus dem Boden zu entfernen die es in Blättern speichern
Zur Phytosanierung von Trinkwasser bietet sich die Dickstielige Wasserhyazinthe an die Arsen insbesondere in ihr Wurzelgewebe einlagert und so eine Abreicherung des kontaminierten Wassers bewirkt
Organische Arsenverbindungen in belasteten Böden können enzymatisch mit Hilfe von Pilzen abgebaut werden
In Bangladesh wird nach einem Verfahren der schweizerischen Forschungseinrichtung EAWAG versucht Arsen mit Hilfe von transparenten PET-Flaschen und Zitronensaft abzureichern
Bei dieser SORAS Solar Oxidation and Removal of Arsenic genannten Methode oxidiert Sonnenlicht das Arsen die Inhaltsstoffe des Zitronensafts helfen bei der Ausfällung
Mit dieser kostengünstigen Methode lässt sich der Arsengehalt um <num> bis <num> Prozent senken
In Gewässern des Yellowstone-Nationalparks die sich aus Geysiren und anderen Thermalquellen vulkanischen Ursprungs speisen wurden eukaryontische Algen der Gattung Cyanidioschyzon gefunden die die hohen Arsenkonzentrationen der Gewässer tolerieren und sie zu biologisch weniger verfügbaren organischen Verbindungen oxidieren können
An einer Nutzung zur Abreicherung in Trinkwasser wird gearbeitet
Antidote
Als Antidote bei akuten Arsenvergiftungen stehen die schwefelhaltigen Komplexbildner Dimercaptopropansulfonsäure DMPS Dimercaptobernsteinsäure und das ältere schlechter verträgliche Dimercaprol zur Verfügung
Sie sind noch bei starken Arsendosen effektiv wenn die Vergiftung rechtzeitig diagnostiziert wird
Ihr Stellenwert bei der Behandlung chronischer Arsenvergiftungen ist hingegen umstritten
Aktivkohle ein bis mehrere Stunden nach der Einnahme kann das Metall ebenfalls binden und zur Ausscheidung bringen
Prophylaxe
Indische Forscher haben im Tierversuch herausgefunden dass die Einnahme von Knoblauch zur Senkung der Arsengehalte im Blut und der Erhöhung der Arsengehalte im Urin führen kann
Erklärt wird dies über eine Ausfällung des Arsen bei Reaktion mit schwefelhaltigen Substanzen wie etwa Allicin das Bestandteil des Knoblauchs ist
Zur Prophylaxe werden zwei bis drei Knoblauchzehen täglich empfohlen
Nachweis
Anorganische Nachweisreaktionen
Arsenverbindungen zeigen beim Verbrennen eine wenig charakteristische fahlblaue Flammenfärbung
Bei der Glühröhrchenprobe erhitzt man Arsenverbindungen welche teilweise sublimieren und sich an kalten Oberflächen in Form von schwarzem Arsen weißem ArsenIII-oxid oder gelbem Arsentrisulfid wieder niederschlagen
Die so genannte Marshsche Probe ist die klassische Nachweisreaktion in der Chemie und Gerichtsmedizin für Arsen As<num>O<num>
<num>Zn
<num>H<num>O -> <num>AsH<num>
<num>Zn<num>
<num>H<num>O
Bei der Bettendorfschen Probe oxidiert Arsen in konzentrierter Salzsäure unabhängig von der Oxidationsstufe zweiwertige Zinn-Ionen
Dabei fällt elementares Arsen aus <num>As<num>
<num>Sn<num> -> <num>Sn<num>
<num>As
Gibt man zu einer ammoniakalischen ammoniumchloridhaltigen Lösung von Arsenat Magnesium-Ionen so erhält man einen kristallinen Niederschlag von Magnesiumammoniumarsenat-Hexahydrat AsO<num><num>-
Mg<num>
NH<num>
<num>H<num>O -> MgNH<num>AsO<num>H<num>O Arsenat reagiert mit Magnesiumionen Ammoniumionen und Wasser zu Magnesiumammoniumarsenat-Hexahydrat
Eine weitere Nachweisreaktion von Arsenat in wässriger Lösung ist die Fällung mit Ammoniumheptamolybdat
Der gelbe Niederschlag ist schwerlöslich in Säuren aber gut löslich in Basen H<num>AsO<num>-
<num>H<num>O
<num>NH<num>
<num>MoO<num><num>- -> NH<num><num>AsMo<num>O<num><num>aq
<num>H<num>O Dihydrogenarsenat reagiert mit Wasserstoffionen Ammoniumionen und Molybdationen zu Ammoniumarsenomolybdat und Wasser
Instrumentelle Bestimmungsverfahren für Arsen
Atomabsorptionsspektrometrie AAS
Bei der Flammen-AAS werden die Arsenverbindungen in einer reduzierenden Luft-Acetylen-Flamme ionisiert
Anschließend wird eine Atomabsorptionsmessung bei <num> nm beziehungsweise <num> nm durchgeführt
Nachweisgrenzen bis zu <num> µgml wurden beschrieben
Häufig wird das Arsen auch mit Hilfe von NaBH<num> in das gasförmige Arsin AsH<num> überführt Hydridtechnik
In der Quarzrohrtechnik wird AsH<num> zuerst bei rund <num> C in einem elektrisch beheizten Quarzröhrchen thermisch in seine atomaren Bestandteile zersetzt um anschließend die Absorption bei o g
Wellenlängen zu bestimmen
Die Nachweisgrenze bei dieser Technik liegt bei <num> µgl Eine weitere Methode ist die sog Graphitrohrtechnik bei der das Arsen einer festen Probe bei <num> C und höher verflüchtigt und anschließend die Extinktion bei <num> nm gemessen wird
Atomemissionsspektrometrie
Die Kopplung von Hydridtechnik mit dem induktiv gekoppelten Plasma laserinduzierter Fluoreszenzmessung ist eine sehr nachweisstarke Methode zur Bestimmung von Arsen
Mittels Hydriderzeugung freigesetztes AsH<num> wird dabei im Plasma atomisiert und mit einem Laser zur Emission angeregt
Mit dieser Methode wurden Nachweisgrenzen von <num> ngmL erreicht
Massenspektrometrie MS
Bei der Massenspektrometrie wird die Arsenspezies zunächst durch ein induktiv gekoppeltes Argonplasma ICP-MS thermisch ionisiert
Anschließend wird das Plasma in das Massenspektrometer geleitet
Eine Nachweisgrenze von <num> µgl wurde für Arsenit beschrieben
Photometrie
Weitverbreitet ist die photometrische Erfassung von As als Arsenomolybdänblau
AsV reagiert zunächst mit NH<num><num>MoO<num>
Danach folgt eine Reduktion mit SnCl<num> oder Hydrazin zu einem blauen Komplex
Die Photometrie erfolgt bei <num> nm und ist somit nahezu störungsfrei
Die Nachweisgrenzen können durch Verwendung von basischen Farbstoffen als Komplexbildner verbessert werden
Neutronenaktivierungsanalyse
Eine sehr empfindliche Arsenbestimmung im ppt-Bereich ist mittels Neutronenaktivierungsanalyse möglich Sie kommt insbesondere dann zur Anwendung wenn die Probe eine komplexe Zusammensetzung aufweist oder schwierig aufzuschließen ist
Allerdings gibt diese Methode keinen Hinweis auf die chemische Verbindung in der das Arsen vorliegt
Bei der Wechselwirkung von Neutronen mit der Probe die das natürliche Isotop Arsen-<num> enthält wird das schwerere Isotop Arsen-<num> gebildet das jedoch instabil ist und sich unter einem β-Zerfall in Selen-<num> umwandelt
Gemessen werden dabei die β-Strahlen über die ein Rückschluss auf die Menge des Arsens möglich ist
<num>_<num>As
<num>_<num>n -> <num>_<num>As -> <num>_<num>Se
e-
Biosensoren
Bei Biosensoren wird die Biolumineszenz bei Kontakt von in Wasser gelöstem Arsen mit genetisch modifizierten Bakterien z B
Escherichia coli
K<num> und eines Lichtmessgeräts Luminometer detektiert
Die vorhandene Arsenkonzentration korreliert dabei direkt mit der emittierten Lichtmenge
Verbindungen
Arsenwasserstoffe
Chemische Verbindungen von Arsen und Wasserstoff
Arsane sind im Vergleich zu den entsprechenden Verbindungen der Hauptgruppennachbarn Stickstoff und Phosphor nicht sehr zahlreich und sehr instabil
Es sind zurzeit drei Arsane bekannt
Arsenwasserstoff auch Monoarsan oder Arsin genannt mit der Summenformel AsH<num> ist eine wichtige Ausgangssubstanz zur Herstellung von Galliumarsenid in der Halbleiterindustrie
Diarsan As<num>H<num>
Triarsan As<num>H<num>
Halogenverbindungen
Arsen bildet mit Halogenen binäre Verbindungen vom Typ AsX<num> AsX<num> und As<num>X<num> X bezeichnet das entsprechende Halogen
ArsenIII-fluorid AsF<num>
ArsenV-fluorid AsF<num>
ArsenIII-chlorid AsCl<num>
Arsenpentachlorid AsCl<num>
Arsentribromid AsBr<num>
Arsentriiodid AsI<num>
Diarsentetraiodid As<num>I<num>
Sauerstoffverbindungen
Wichtige Sauerstoffsäuren sind
Arsensäure <num> H<num>AsO<num>
H<num>O deren Salze als Arsenate oder ArsenateV bezeichnet werden und den Phosphaten ähneln
Beispiele sind Calciumarsenat Ca<num>AsO<num><num><num>H<num>O und Bleihydrogenarsenat PbHAsO<num> die als Pflanzenschutzmittel verwendet wurden
Arsenige Säure H<num>AsO<num> deren Salze als Arsenite oder ArsenateIII bezeichnet werden
Das wichtigste Arsenoxid ist ArsenIII-oxid Arsentrioxid auch Arsenik oder Weißarsenik As<num>O<num> das Anhydrid der Arsenigen Säure das in der Gasphase in Form von Doppelmolekülen mit der Formel As<num>O<num> vorliegt
Es ist amphoter und weist damit auf den Halbmetallcharakter des Arsens hin
Neben As<num>O<num> kennt man As<num>O<num> Arsenpentaoxid das Anhydrid der Arsensäure und das gemischte Anhydrid der Arsenigen Säure und Arsensäure As<num>O<num> Arsentetraoxid
Ein historisch wichtiges Färbe- und Pflanzenschutzmittel ist ein Kupfer-Arsen-Oxid mit dem Trivialnamen Schweinfurter Grün CuAsO<num><num>CuCH<num>COO<num>
Schwefelverbindungen
Es bestehen zwei wichtige Arsensulfide die beide als Minerale in der Natur vorkommen
Arsenmonosulfid Realgar As<num>S<num>
ArsenIII-sulfid Auripigment As<num>S<num>
Arsen-Metall-Verbindungen
Wichtige Verbindungen von Arsen mit Metallen sind
Galliumarsenid GaAs ein wichtiger Halbleiter
Indiumarsenid InAs ein wichtiger Halbleiter
Nickelarsenid NiAs
Aluminiumgalliumarsenid AlGaAs
Organische Verbindungen
In Analogie zu den Aminen und Phosphinen findet man entsprechende Verbindungen mit Arsen anstelle von Stickstoff oder Phosphor
Sie werden als Arsine bezeichnet
Dimethylarsin AsHCH<num><num>
Trimethylarsin AsCH<num><num> eine übelriechende Flüssigkeit die zur Behandlung bakterieller Infektionen und als Pilzschutzmittel Anwendung fand
Zu den Arsoranen Verbindungen vom Typ R<num>As wobei R<num> für fünf - möglicherweise unterschiedliche - organische Gruppen steht zählt man etwa Pentaphenylarsen oder Pentamethylarsen
Fehlt eine der fünf Gruppen bleibt ein einfach positiv geladenes Ion zurück R steht wiederum für - möglicherweise verschiedene - organische Gruppen das man als Arsoniumion AsR<num> bezeichnet
DateiPolyzyklisches Arsenpng
Analog zu den Carbonsäuren lassen sich zwei Klassen arseno-organischer Säuren bilden
Arsinsäuren RRAsOOH
Arsonsäuren RAsOOH<num>
Zudem sind Heteroaromaten mit Arsen als Heteroatom bekannt wie Arsabenzol das aus einem Benzolring besteht in dem ein Kohlenstoffatom durch Arsen ersetzt ist und das somit analog zu Pyridin aufgebaut ist
DateiPolyarsinpng
Auch homocyclische Arsenverbindungen existieren
Beispiele sind
Pentamethylcyclopentaarsen AsCH<num><num>
Hexamethylcyclohexaarsen AsCH<num><num>
deren Moleküle einen Fünf- beziehungsweise Sechsring aus Arsenatomen als Rückgrat aufweisen an den nach außen hin je eine Methylgruppe pro Arsenatom gebunden ist
Eine polycyclische Variante bildet das nebenstehende Molekül dessen Rückgrat sich aus einem Sechs- und zwei angehefteten Fünfringen zusammensetzt R steht für jeweils eine tert-Butylgruppe
Schließlich lassen sich Arsenpolymere darstellen lange Kettenmoleküle die als Polyarsine bezeichnet werden
Sie bestehen aus einer zentralen Strickleiter der Arsenatome an die außen auf jeder Seite je Sprosse eine Methylgruppe angeheftet ist so dass sich die chemische Formel AsCH<num><num>n ergibt wobei die natürliche Zahl n weit über <num> liegen kann
Polyarsine zeigen deutliche Halbleitereigenschaften
Bioorganische Verbindungen
In der Bioorganik spielen Arsenolipide Arsenosaccharide und arsenhaltige Glycolipide eine bedeutende Rolle
Wichtige Vertreter dieser Stoffklassen sind zum Beispiel Arsenobetain Arsenocholin und unterschiedlich substituierte Arsenoribosen
Sie treten vor allem kumuliert in maritimen Lebewesen auf und können auf diesem Weg in die menschliche Nahrungskette gelangen
Arsenhaltige Biomoleküle konnten in Algen Meeresschwämmen und in Fischgewebe nach erfolgter Extraktion mittels HPLC-ICP-MS nachgewiesen werden
Die Analytik von Organo-Arsenverbindungen einschließlich ihrer Speziation ist sehr aufwändig
Arsen in Kriminalgeschichte Literatur und Film
Das Element Arsen erreichte zweifelhafte Berühmtheit als Mordgift belegt durch geschichtliche Aufzeichnungen sowie die Instrumentalisierung in Literatur und Film
Es handelte sich bei dem Mordgift allerdings nie um elementares Arsen sondern um dessen Verbindungen
In Italien und Frankreich starben Herzöge Könige und Päpste an vorsätzlich herbeigeführten Arsenvergiftungen
Im Frankreich des <num> Jahrhunderts steht die Marquise de Brinvilliers die ihren Vater und zwei Brüder mit einer Arsenikmischung vergiftete im Mittelpunkt eines Giftskandals
In Deutschland brachte die Serienmörderin Gesche Gottfried aus Bremen <num> Menschen zu Tode
Aufsehen erregte auch der Fall der Serienmörderin Anna Margaretha Zwanziger zu Beginn des <num> Jahrhunderts
Die Urheber der Morde blieben jedoch meist unerkannt da Arsen bis <num> in kleinen Mengen nicht nachgewiesen werden konnte
Erst die durch James Marsh entwickelte und nach ihm benannte Marshsche Probe machte es möglich Spuren des Elementes zu identifizieren und somit eine unnatürliche Todesursache nachzuweisen
Im <num> und <num> Jahrhundert fanden weiter vorsätzliche Vergiftungen mit arsenhaltigen Mitteln statt - zum einen weil sie leicht als Herbizide verfügbar waren zum anderen ließ sich bei chronischer Gabe kleiner Dosen ein krankheitsbedingter Tod vortäuschen
Im September <num> fiel im Prozess gegen Marie Lafarge das erste Urteil das alleine auf den Ergebnissen der Marshschen Probe beruhte
Im Fall der Marie Besnard die angeblich zwischen <num> und <num> für mehrere Todesfälle in ihrem Umfeld in Loudun verantwortlich sein sollte konnte ein eindeutiger Beweis nicht erbracht werden weil Untersuchungsergebnisse widersprüchlich waren und sie musste <num> letztendlich freigesprochen werden
DateiThe Imperial Portrait of Emperor Guangxu<num>jpg DateiNapoleon - <num>jpg Jahrelang glaubte die Fachwelt dass der Tod des ehemaligen französischen Kaisers Napoleon Bonaparte mit <num> Jahren auf der Insel St
Helena
einem Giftanschlag mit Arsen zugeschrieben werden muss
Zumindest hatte man in seinen Haaren hochkonzentrierte Spuren des Giftes entdeckt
Heute existieren verschiedene andere Thesen zur Erklärung des Faktenbefunds
Eine Möglichkeit besteht darin dass das Arsen nach seinem Tod den Haaren beigegeben wurde um diese zu konservieren eine damals durchaus übliche Methode
Möglich ist ein Übermaß der Benutzung der arsenhaltigen Fowlersche Lösung die zu seiner Zeit bei vielen seiner Zeitgenossen als medizinisches Wundermittel galt
Die dritte und heute als wahrscheinlichste angesehene Möglichkeit ist dass sich Napoleon durch organische Arsenverbindungen vergiftete die Schimmelpilze beständig aus seinen mit grünen Arsenpigmenten gefertigten Tapeten freisetzten
Deren hoher Arsengehalt ist durch eine <num> in einem Notizbuch aufgefundene Materialprobe schlüssig belegt
Der berühmte Philosoph René Descartes starb <num> wenige Monate nach seiner Ankunft am Hofe der schwedischen Königin Christine
Der Verdacht er sei von einem der Jesuiten die sich am Hofe der protestantischen Königin aufhielten aus religionspolitischen Gründen mit Arsen vergiftet worden verstärkte sich als Christine später tatsächlich zum Katholizismus konvertierte konnte aber nicht erhärtet werden so dass die offizielle Todesursache Lungenentzündung sich in den Biographien etablierte
Erst kürzlich wurde anhand von neu aufgefundenen und neu interpretierten Dokumenten der alte Verdacht erhärtet und behauptet dass der Giftmord an Descartes in sehr hohem Maße wahrscheinlich um nicht zu sagen fast sicher erscheint
Im Jahre <num> kam es im britischen Manchester zu einer Massenvergiftung von der mehrere Tausend Menschen betroffen waren
Wie sich herausstellte hatten alle Bier derselben Brauerei getrunken
In Vorstufen der Bierproduktion wurde anscheinend Schwefelsäure eingesetzt die ihrerseits aus Schwefel hergestellt wurde der aus mit Arsenopyrit kontaminierten Sulfidmineralen stammte
Etwa <num> Menschen erlagen ihren Vergiftungen
In den Jahren <num> und <num> starben in Österreich zwei Männer an einer Arsenvergiftung
Am <num> April <num> wurde am Landesgericht Krems eine <num>-jährige Polin des Mordes an den beiden für schuldig befunden und von dem Geschworenengericht nicht rechtskräftig zu lebenslanger Haft verurteilt Noch in den <num>er Jahren auf dem Höhepunkt des Kalten Krieges erkrankte die US-amerikanische Botschafterin Clare Booth Luce in Rom durch eine Vergiftung mit dem aus Tapeten freigesetzten Arsen
Die Tatsache dass die Krankheit auf die schimmelpilzbefallenen Tapeten und nicht auf gegnerische Geheimagenten zurückgeführt werden konnte trug in diesem Fall nicht nur zur Genesung der Botschafterin sondern auch zum Erhalt des Friedens bei
In Friedrich Schillers bürgerlichem Trauerspiel Kabale und Liebe vergiftet der junge Major Ferdinand von Walter erst seine Geliebte Luise Millerin und dann sich selbst
Allerdings tritt in Kabale und Liebe der Tod unrealistischerweise binnen Minuten ein
Die Protagonistin des berühmten Romans
Madame Bovary
von Gustave Flaubert die unglücklich verheiratete Landarztgattin Emma Bovary stirbt am Ende des Romans durch Suizid mit Arsen in Form eines weißen Pulvers
Der Spross einer Arztfamilie Flaubert beschreibt die Vergiftungssymptome und den äußerst qualvollen Tod der Bovary sehr detailliert
Im Roman Starkes Gift Strong Poison von Dorothy L Sayers ist das Opfer mit Arsen vergiftet worden
Die Verdächtige Krimi-Schriftstellerin Harriet Vane hat sich zur fraglichen Zeit intensiv mit Arsenmorden beschäftigt und sich dazu sogar vom Apotheker beraten lassen
Der berühmte Detektiv Kalle Blomquist aus dem gleichnamigen Kinderbuch von Astrid Lindgren wendete die Marshsche Probe an um ein mit Arsen vergiftetes Stück Schokolade zu überprüfen
In dem Theaterstück von Joseph Kesselring
Arsen und Spitzenhäubchen
englisch Arsenic and Old Lace vergiften zwei alte Damen in gutmeinender Absicht ältere einsame Herren mit einer Arsen- Strychnin- und Zyankali-Mischung
Bekannt wurde das Stück durch die gleichnamige Verfilmung von Frank Capra mit Cary Grant Peter Lorre und Priscilla Lane in den Hauptrollen
Literatur
Erwin Riedel Anorganische Chemie
de Gruyter Berlin <num> ISBN <num>-<num>-<num>-<num>
Dietmar Ritter Charakterisierung und Einsatz alternativer Arsen- und Phosphor-Quellen für die Metallorganische Molekularstrahlepitaxie von InP und GaInAs Shaker Aachen <num> ISBN <num>-<num>-<num>-<num>
Giulio Morteani Lorenz Eichinger Arsen im Trinkwasser und Dearsenierung
Gesetzliche Vorschriften Toxikologie Hydrochemie
In Wasser Luft Boden Vereinigte Fachverlag Mainz <num> <num> <num> S <num>-<num>
Nicholas C Norman Chemistry of Arsenic Antimony and Bismuth Blackie London <num> ISBN <num>-<num>-<num>-X
Andrew A Meharg Venomous Earth How arsenic caused the worlds worst mass poisoning Macmillan Science
Die bremische Gesina In Hans Heinrich Frau-Geschichten WM-Literatur-Verlag Weilheim <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Weblinks
MineralienatlasArsen Enzymatischer Abbau von Arsenkampfstoffen wissenschaftde - Arsen im Trinkwasser begünstigt Arteriosklerose Arsenic and Human Health Environmental Health
Toxicology Specialized Information Services National Library of Medicine englisch
PDF <num> KiB
Einzelnachweise
Jorma Maeki-Paakkanen Päivi Kurttio Anna Paldy Juha Pekkanen
PDF In Environmental and Molecular Mutagenesis <num> Nr <num> <num> S <num>-<num> Oyeronke A Odunola Aliyu Muhammad Ahsana D Farooq Kourosh Dalvandi Huma Rasheed Muhammad I Choudhary Ochuko L Erukainure Comparative assessment of redox-sensitive biomarkers due to acacia honey and sodium arsenite administration in vivo In Mediterranean Journal of Nutrition and Metabolism <num> Nr <num> <num> S <num>-<num> doi<num>s<num>-<num>-<num>-<num> Bernhard Fischer Ueber Todesfälle nach Salvarsan In
Deutsche Medizinische Wochenschrift Band <num> <num> S <num> f <num>-<num> <num>-<num> und <num>-<num> J Elfenbein Der erste Krimi der Weltgeschichte Teil <num> Die Machtergreifung des König Darius In Borsuye Zeitschrift für Medizin u Kultur <num> <num> <num> S <num> f Doris Schwarzmann-Schafhauser Arsen In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num> S <num> K H Wedepohl The composition of the continental crust In
Geochimica et Cosmochimica Acta <num><num> <num> S <num>-<num> IMACNMNC List of Mineral Names - Gold PDF <num> MB S <num> englisch Localities for Arsenic Mindat Mineral Species sorted by the element As Arsenic Webmineral G Brauer Hrsg Handbook of Preparative Inorganic Chemistry <num> Auflage vol <num> Academic Press <num> S <num>-<num> NA J M Hyson A history of arsenic in dentistry In Journal of the California Dental Association Band <num> Nummer <num> Februar <num> S <num>-<num> PMID <num> M Hülsmann Risiken und Nebenwirkungen bei der Devitalisierung permanenter Zähne In Zahnärztl Mitt <num> <num> S <num>-<num> Ernst Sieburg Zur Biologie aromatischer Arsenverbindungen In
Hoppe-Seylers Zeitschrift für physiologische Chemie Band <num> <num> S <num>-<num> Vgl auch Florian G Mildenberger Kein Heil durch Arsen Die Salvarsandebatte und ihre Konsequenzen In Fachprosaforschung - Grenzüberschreitungen Band <num><num> <num><num> <num> S <num>-<num>Fernando Marte Amandine Pequinot David W Von Endt
PDF <num> kB Gerhard Schröder Das Sammeln Konservieren von Wirbeltieren <num> Rudolf Piechocki Joachim Händel Mikroskopische Präparationstechnik Teil II <num> Auflage <num>Felix Divo
Jugend-forscht-Arbeit von <num> John Emsley Parfum Portwein PVC
Wiley Verlag Weinheim <num> S <num>-<num> M Banerjee N Banerjee P Bhattacharjee D Mondal P R Lythgoe M Martínez J Pan D A Polya A K Giri High arsenic in rice is associated with elevated genotoxic effects in humans In Scientific reports Band <num> Juli <num> S <num> doi<num>srep<num> PMID <num> Felisa Wolfe-Simon Jodi Switzer Blum Thomas R Kulp Gwyneth W Gordon Shelley E Hoeft Jennifer Pett-Ridge John F Stolz Samuel M Webb Peter K Weber Paul C W Davies Ariel D Anbar Ronald S Oremland A Bacterium That Can Grow by Using Arsenic Instead of Phosphorus In
Science
<num> doi<num>science<num> Erika Check Study challenges existence of arsenic-based life Study challenges existence of arsenic-based life In nature news <num> Januar <num> doi<num>nature<num> M L Reaves S Sinha J D Rabinowitz L Kruglyak R J Redfield Absence of arsenate in DNA from arsenate-grown GFAJ-<num> cells <num> April <num>
Johann Mutschmann Fritz Stimmelmayr Taschenbuch der Wasserversorgung ViewegTeubner <num> ISBN <num>-<num>-<num>-<num>-<num> Arsenic Removal Using Nanoscale Magnetite Richtlinie <num><num>EG des Rates vom <num> November <num> über die Qualität von Wasser für den menschlichen Gebrauch
eur-lexeuropaeu DPA-Meldung auf merkur-onlinede vom <num> Juli <num> abgerufen am <num> November <num>
auf der Webseite der FAO abgerufen am <num> November <num> englisch
PDF eceuropaeu abgerufen am <num> November <num> englisch Keiligh Baker
In
Daily Mail <num> November <num> abgerufen am <num> November <num> englisch Nadja Podbregar
In
wissenschaftde <num> April <num> abgerufen am <num> November <num>
In
Washington Post <num> Mai <num> abgerufen am <num> November <num> englisch
auf der Webseite des LGL Bayern aktualisiert am <num> Mai <num> abgerufen am <num> November <num> T K Morris Cadmium exposures at three nonferrous foundries an unexpected trace source In J Occup Environ Hyg <num><num> Jan <num> S <num>-<num> Ohio Bureau of Workers Compensation Division of Safety and Hygiene Cincinnati OH Jie Qin u a Biotransformation of arsenic by a Yellowstone thermoacidophilic eukaryotic alga In
Proceedings of the National Academy of Sciences Abstract R Lobinski Z Marcenko Spectrochemical Trace Analysis for Metals and Metalloids Elsevier <num> P Liang L Peng P Yan Speciation of AsIII and AsV in water samples by liquid-liquid microextraction separation and determination by graphite furnace atomic absorption spectrometry In
Microchimica Acta <num> <num> S <num>-<num> and darin genannte Zitationen Y Jiang J Liu X Xia D Wang Ammonium pyrrolidinedithiocarbamate-modified activated carbon micro-column extraction for the determination of AsIII in water by graphite furnace atomic absorption spectrometry In Microchimica Acta <num> <num> S <num>-<num> D Hung O Nekrassova R Compton Analytical Methods for Inorganic Arsenic in Water A Review In
Talanta <num> <num> S <num>-<num> J Mattusch R Wennrich Novel Analytical Methodologies for the Determination of Arsenic and other Metalloid Species in Solids Liquids and Gases In Microchimica Acta <num> <num> S <num>-<num> S Londesborough J Mattusch R Wennrich Separation of organic and inorganic arsenic species by HPLC-ICP-MS In Fresenius Journal of Analytical Chemistry <num> <num> S <num>-<num> G Schwedt Analytische Chemie <num> Auflage Wiley-VCH <num> S <num>
PDF Helmholtz-Zentrum für Umweltforschung Escherichia coli Bakterien in Arsen Detektoren <num> März <num> K O Amayo A Raab E M Krupp T Marschall M Horsfall Jr J Feldmann Arsenolipids show different profiles in muscle tissues of four commercial fish species J Trace Elem Med Biol <num> Nov <num> pii S<num>-<num>X<num><num>-<num> PMID <num> V Dembitsky D Levitsky Arsenolipides In Progress in Lipid Research <num> <num> S <num>-<num> Theodor Ebert Philosoph Interview zu seinem Buch Der rätselhafte Tod des René Descartes Alibri Aschaffenburg <num> orfat Lebenslange Haft im Arsen-Prozess abgerufen am <num> April <num>
Astat
von
unbeständig unstet ist ein radioaktives chemisches Element mit dem Elementsymbol At und der Ordnungszahl <num> Im Periodensystem steht es in der <num> Hauptgruppe bzw der <num> IUPAC-Gruppe und zählt damit zu den Halogenen
Astat entsteht beim natürlichen Zerfall von Uran
Astat ist eines der seltensten natürlich vorkommenden Elemente der Erde das bei Bedarf künstlich erzeugt werden muss
Geschichte
ateiSegrejpgEmilio Gino Segrè Entdecker des Astats
Dmitri Mendelejew
Iod
Im Jahre <num> behauptete Fred Allison er und seine Mitarbeiter am Alabama Polytechnic Institute heute Auburn University hätten das fehlende Element entdeckt und gaben ihm die Bezeichnung Alabamine Ab
Ihre Entdeckung konnte jedoch nicht bestätigt werden und wurde später als falsch erkannt
Ebenfalls auf der Suche nach einem Mitglied der Familie des radioaktiven Thoriums fand der Chemiker De Rajendralal Mitra im Jahre <num> in Dhaka Bangladesch damals Britisch-Indien zwei neue Elemente
Das erste nannte er Dakin Eka-Iod wohl nach der englischen Bezeichnung für Dhaka Dacca das andere Gourium Beide Entdeckungen konnten jedoch nicht bestätigt werden
Der Name Helvetium wurde wiederum von dem Schweizer Chemiker Walter Minder vorgeschlagen als er die Entdeckung des Elements <num> im Jahr <num> ankündigte
Er änderte im Jahr <num> jedoch seinen Vorschlag in Anglohelvetium
Bestätigt werden konnte die Entdeckung des Astat altgriechisch ἀστατέω
unbeständig sein aufgrund des radioaktiven Zerfalls erstmals im Jahre <num> durch die Wissenschaftler Dale Corson Kenneth MacKenzie und Emilio Gino Segrè die es in der University of California künstlich durch Beschuss von Bismut mit Alphateilchen herstellten
Drei Jahre später konnte das kurzlebige Element von Berta Karlik und Traude Bernert auch als Produkt des natürlichen Zerfallsprozesses von Uran gefunden werden
Gewinnung und Darstellung
Astat wird durch Beschuss von Bismut mit Alphateilchen im Energiebereich von <num> bis <num> MeV hergestellt
Man erhält dabei die relativ langlebigen Isotope <num>At bis <num>At die dann im Stickstoff strom bei <num> bis <num> C sublimiert und an einer gekühlten Platinscheibe abgetrennt werden
Eigenschaften
Bei diesem radioaktiven Element wurde mit Hilfe von Massenspektrometrie nachgewiesen dass es sich chemisch wie die anderen Halogene besonders wie Iod verhält es sammelt sich wie dieses in der Schilddrüse an
Astat ist stärker metallisch als Iod
Forscher am Brookhaven National Laboratory haben Experimente zur Identifikation und Messung von elementaren chemischen Reaktionen durchgeführt die Astat beinhalten
Mit dem On-line-Isotopen-Massenseparator ISOLDE am CERN wurde <num> das Ionisationspotenzial von Astat mit <num><num> Elektronenvolt bestimmt
Isotope
Astat hat etwa <num> bekannte Isotope die alle radioaktiv sind das langlebigste ist <num>At mit einer Halbwertszeit von <num> Stunden
Verwendung
Organische Astatverbindungen dienen in der Nuklearmedizin zur Bestrahlung bösartiger Tumore
Astat-Isotope eignen sich aufgrund der kurzen Halbwertszeiten innerlich eingenommen als radioaktive Präparate zum Markieren der Schilddrüse
Das Element wird in der Schilddrüse angereichert und in der Leber gespeichert
Verbindungen
Die chemischen Eigenschaften von Astat konnten aufgrund der geringen Mengen bisher nur mit Tracerexperimenten festgestellt werden
Sie ähneln stark denjenigen des Iods wobei es aber ein schwächeres Oxidationsmittel ist
Bisher konnten diverse Astatide Interhalogenverbindungen und organische Verbindungen nachgewiesen werden
Auch die Anionen der entsprechenden Sauerstoffsäuren sind bekannt
Wegen des im Vergleich zu anderen Halogenen elektropositiveren Charakters wird es von Silber nur unvollständig ausgefällt
Dafür existiert das komplexstabilisierte Kation AtPy<num> PyPyridin wodurch Astat auch kathodisch abgeschieden werden kann
Nachgewiesen wurde auch das Hydrid Astatwasserstoff HAt
Sicherheitshinweise
Einstufungen nach der CLP-Verordnung liegen nicht vor weil diese nur die chemische Gefährlichkeit umfassen und eine völlig untergeordnete Rolle gegenüber den auf der Radioaktivität beruhenden Gefahren spielen
Auch Letzteres gilt nur wenn es sich um eine dafür relevante Stoffmenge handelt
Literatur
Eric Scerri A tale of seven elements Oxford University Press Oxford <num>
Einzelnachweise
Weblinks
Wolfgang W Merkel
in Weltde Datum <num> September <num> abgerufen am <num> September <num> Fred Allison Edgar J Murphy Edna R Bishop Anna L Sommer Evidence of the Detection of Element <num> in Certain Substances In Phys Rev <num> <num> S <num>-<num>
R F Trimble What happened to alabamine virginium and illinium In J Chem Educ <num> <num> S <num> <num> Astatine Alice Leigh-Smith Walter Minder Experimental Evidence of the Existence of Element <num> in the Thorium Family In Nature <num> <num> S <num>-<num>
D R Corson K R MacKenzie E Segrè Artificially Radioactive Element <num> In Phys Rev <num> <num> S <num>-<num>
Berta Karlik Traude Bernert Eine neue natürliche α-Strahlung In Naturwissenschaften <num> <num> <num>-<num> S <num>-<num>
Berta Karlik Traude Bernert Das Element <num> in den natürlichen Zerfallsreihen In Zeitschrift für Physik <num> <num> <num>-<num> S <num>-<num>
Welt der Physik
Deutsche Physikalische Gesellschaft eV über das Ionisationspotential von Astat <num>
Als Alkalimetalle werden die chemischen Elemente Lithium Natrium Kalium Rubidium Caesium und Francium aus der <num> Hauptgruppe des Periodensystems bezeichnet
Sie sind silbrig glänzende reaktive Metalle die in ihrer Valenzschale ein einzelnes Elektron besitzen
Obwohl Wasserstoff in den meisten Darstellungen des Periodensystems in der ersten Hauptgruppe steht und zum Teil ähnliche chemische Eigenschaften wie die Alkalimetalle aufweist kann er nicht zu diesen gezählt werden da er unter Standardbedingungen weder fest ist noch metallische Eigenschaften aufweist
Erklärung des Namens
Der Name der Alkalimetalle leitet sich von dem arabischen Wort
für Pottasche ab die alte Bezeichnung für aus Pflanzenaschen gewonnenes Kaliumcarbonat
Humphry Davy stellte im Jahre <num> erstmals das Element Kalium durch eine Schmelzflusselektrolyse aus Kaliumhydroxid dar
Letzteres gewann er aus Kaliumcarbonat
In einigen Sprachen spiegelt sich dies im Namen wider
So heißt Kalium beispielsweise im Englischen und Französischen potassium und im Italienischen potassio
Eigenschaften
DateiAlkalimetallejpg
Alkalimetalle sind metallisch glänzende silbrig-weiße Ausnahme Caesium hat bei geringster Verunreinigung einen Goldton weiche Leichtmetalle
Sie sind mit dem Messer schneidbar
Alkalimetalle haben eine geringe Dichte
Sie reagieren mit vielen Stoffen so beispielsweise mit Wasser Luft oder Halogenen teilweise äußerst heftig unter starker Wärmeentwicklung
Insbesondere die schwereren Alkalimetalle können sich an der Luft selbst entzünden
Daher werden sie unter Schutzflüssigkeiten wie Paraffin oder Petroleum Lithium Natrium und Kalium bzw unter Luftabschluss in Ampullen Rubidium und Caesium aufbewahrt
Als Elemente der ersten Gruppe des Periodensystems besitzen sie nur ein schwach gebundenes s-Elektron das sie leicht abgeben
Ihre ersten Ionisierungsenergien und ihre Elektronegativitäten sind entsprechend klein
In Verbindungen kommen sie alle fast ausschließlich als einwertige Kationen vor wenngleich sogar Verbindungen bekannt sind in denen diese Metalle anionisch vorliegen z B
Natride komplexiert mit sogenannten Kryptanden
Alkalimetalle und ihre Salze besitzen eine spezifische Flammenfärbung
Lithium und seine Salze färben die Flamme rot <num> nm
Natrium und seine Salze färben die Flamme gelb <num> nm
Kalium und seine Salze färben die Flamme violett <num> und <num> nm
Rubidium und seine Salze färben die Flamme rot <num> und <num> nm
Caesium und seine Salze färben die Flamme blauviolett <num> nm
Aufgrund dieser Flammenfärbung werden Alkalimetallverbindungen für Feuerwerke benutzt
In der Atomphysik werden Alkalimetalle eingesetzt da sie sich aufgrund ihrer besonders einfachen elektronischen Struktur besonders leicht mit Lasern kühlen lassen
Alle Alkalimetalle kristallisieren in der kubisch-raumzentrierten Struktur
Lediglich Lithium und Natrium kristallisieren in der hexagonal-dichtesten Packung wenn tiefe Temperaturen vorherrschen
Trends
Der Radius der Elementatome sowie der Kationen nimmt mit steigender Massenzahl zu
Viele andere Eigenschaften der Alkalimetalle zeigen einen Trend innerhalb der Gruppe von oben nach unten
Abnahme der Härte Ionisierungsenergie Elektronegativität Schmelz- und Siedepunkte
Zunahme der Reaktivität Basizität und Dichte
Reaktionsverhalten und Verbindungen
Die Alkalimetalle reagieren mit Wasserstoff unter Bildung salzartiger Alkalimetallhydride
<num> Me
H_<num> -> <num> MeH
Die thermische Beständigkeit der Hydride nimmt vom Lithiumhydrid LiH zum Caesiumhydrid CsH ab
Alkalihydride werden u a als Reduktions- oder Trockenmittel eingesetzt
Mit Sauerstoff reagieren die Metalle unter Bildung fester weißer Alkalimetalloxide Lithiumoxid Alkalimetallperoxide Natriumperoxid und Alkalimetallhyperoxide Kaliumhyperoxid Rubidiumhyperoxid Caesiumhyperoxid
<num> Li
O_<num> -> <num> Li_<num>O
<num> Na
O_<num> -> Na_<num>O_<num>
<num> Na
O_<num> -> Na_<num>O
M
O_<num> -> MO_<num> M
K Rb Cs
DateiPotassium water <num>theoraogv Die Reaktion mit Wasser zu Alkalimetallhydroxiden erfolgt unter Freisetzung von Wasserstoff
<num> M
<num> H_<num>O -> <num> MOH
H_<num>
Vom Lithium zum Caesium steigt die Reaktivität stark an
Während eine annähernd kubische Probe von Lithium relativ träge reagiert entzündet sich schon bei Natrium aufgrund der Hitzeentwicklung der entstehende Wasserstoff unter Anwesenheit von Luftsauerstoff
Ab dem Kalium erfolgt bei fortschreitender Reaktion auch Verdampfung und Entflammung des Metalls nicht zuletzt auch wegen des mit der Ordnungszahl abnehmenden Siedepunkts siehe oben
Aber auch unter Luftabschluss können schon weniger als <num> g Natrium explosiv mit Wasser reagieren was eigentlich durch die an der Kontaktfläche der Edukte entstehenden Reaktionsprodukte Wasserstoff und Alkalimetalhydroxid gehemmt werden sollte
Hochgeschwindigkeitsaufnahmen eines Experiments bei dem Tropfen einer unter Standardbedingungen flüssigen Legierung aus Kalium und Natrium unter einer Inertgas-Atmosphäre mit Wasser in Kontakt gebracht wurden legen eine initial erfolgende Coulomb-Explosion negative Oberflächenspannung bzw die damit einhergehende starke Oberflächenvergrößerung der mit Ausnahme von Lithium nach kurzer Zeit schmelzflüssigen unlegierten Alkalimetallproben als Ursache für den ungehemmten Ablauf die hohe Geschwindigkeit und damit die Heftigkeit dieser Reaktionen nahe Die Alkalimetallhydroxide sind farblose Feststoffe die sich in Wasser unter starker Erwärmung leicht lösen und dabei stark basisch reagieren
Die Hydroxide und ihre Lösungen wirken stark ätzend
Mit Halogenen reagieren die Alkalimetalle zu den salzartigen
Alkalimetallhalogeniden
<num> Me
X_<num> -> <num> MeX
Die Reaktivität steigt vom Lithium zum Caesium und sinkt vom Fluor zum Iod
So reagiert Natrium mit Iod kaum und mit Brom sehr langsam während die Reaktion von Kalium mit Brom und Iod explosionsartig erfolgt
Alkalimetalle können Halogenkohlenwasserstoffen unter Explosionserscheinungen das Halogen unter Bildung von Kohlenstoff und dem entsprechenden Alkalimetallhalogenid entziehen
CCl_<num>
<num> Na -> <num> NaCl
C
Alkalimetalle ergeben mit flüssigem Ammoniak intensiv blau gefärbte Lösungen
Diese Lösungen die aus positiven Alkalimetall-Ionen und solvatisierten Elektronen besteht sind ein sehr starkes Reduktionsmittel und werden beispielsweise für die Birch-Reduktion eingesetzt
Wird diesen Lösungen ein geeigneter Komplexbildner zugesetzt können sich entsprechende Salze mit Alkalimetall-Anionen die sogenannten Alkalide bilden
Wasserstoff
Wasserstoff das erste Element der <num> Hauptgruppe ist unter Normalbedingungen ein Nichtmetall
Er wird deshalb nicht zu den Alkalimetallen gezählt teilt jedoch mit ihnen einige Eigenschaften
Wasserstoff tritt wie die Alkalimetalle stets einwertig auf und wandelt sich unter extrem hohem Druck in eine metallische Hochdruckmodifikation um den metallischen Wasserstoff
Umgekehrt haben auch einige Alkalimetalle unter bestimmten Bedingungen Eigenschaften wie Wasserstoff z B
besteht Lithium als Gas zu <num>
aus zweiatomigen Molekülen
Literatur
A G Sharpe et al Inorganic Chemistry second edition - ISBN <num>-<num>-<num>-<num> - Kapitel <num> Group <num> the alkali metals
Handbuch der experimentellen Chemie Sekundarbereich II Band <num> Alkali- und Erdalkalimetalle Halogene Aulis Verlag Deubner
Co KG Köln
Weblinks
Pink-Panther-Reaktion Reaktion von Natrium mit Wasser auf Video
Die Alkalimetalle Beschreibung der Alkalimetalle mit vielen Abbildungen
High speed camera reveals why sodium explodes Video zur Ursache der heftigen Reaktion von Alkalimetallen mit Wasser unter Luftabschluss auf dem YouTube-Kanal Thunderf<num>t des Hauptautors des Nature-chemistry-Artikels englisch
Einzelnachweise
P E Mason F Uhlig V Vaněk T Buttersack S Bauerecker P Jungwirth Coulomb explosion during the early stages of the reaction of alkali metals with water In Nature chemistry Band <num> Nummer <num> März <num> S <num>-<num>
PMID <num>
Actinoide
Actiniumähnliche griech Endung -οειδής -oeides ähnlich ist eine Gruppenbezeichnung bestimmter ähnlicher Elemente
Zugerechnet werden ihr das Actinium und die <num> im Periodensystem folgenden Elemente Thorium Protactinium Uran und die Transurane Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium und Lawrencium
Im Sinne des Begriffs gehört Actinium nicht zu den Actiniumähnlichen jedoch folgt die Nomenklatur der IUPAC hier dem praktischen Gebrauch
Die frühere Bezeichnung Actinide entspricht nicht dem Vorschlag der Nomenklaturkommission da nach diesem die Endung -id für binäre Verbindungen wie z B
Chloride reserviert ist die Bezeichnung ist aber weiterhin erlaubt
Alle Actinoide sind Metalle und werden auch als Elemente der Actiniumreihe bezeichnet
Begriffliche Abgrenzung
Die Transurane sind die Elemente mit einer höheren Ordnungszahl als Uran d h
die Actinoide beginnend mit Neptunium <num> sind auch Transurane
Als Transactinoide bezeichnet man die Elemente mit Ordnungszahlen ab <num> Rutherfordium
Sie folgen im Periodensystem auf die Actinoide
Alle Transactinoide sind auch gleichzeitig Transurane da sie Ordnungszahlen größer als die des Urans haben
Im Zusammenhang mit Kernbrennstoffen und radioaktivem Abfall werden Neptunium Americium Curium Berkelium und Californium auch als minore Actinoide bezeichnet
Die Actinoid-Nuklide sind Schwermetalle
In der Reaktorphysik wird bei Abbrandberechnungen der Schwermetall-Begriff etwas eingeschränkt
Als Schwermetalle bezeichnet man in diesem Zusammenhang nur die durch Neutronen spaltbaren Schwermetall-Nuklide
Spaltbar sind alle Schwermetall-Nuklide ab Actinium <num> also auch alle Nuklide der Actinoiden
Massen von Spaltprodukten und Massen der überwiegend durch Neutroneneinfang in einem Kernreaktor entstandenen schweren Nuklide werden meist relativ zur Masse der anfangs eingesetzten so definierten Schwermetalle angegeben
Entdeckung und Gewinnung
Im Jahr <num> publizierte die deutsche Chemikerin Ida Noddack eine Arbeit über drei Lücken im Periodischen System der Elemente die später mit den Elementen Francium Astat und Promethium gefüllt wurden
Gleichsam nebenbei merkte sie an dass es denkbar sei dass bei der Beschießung schwerer Kerne mit Neutronen diese Kerne in mehrere größere Bruchstücke zerfallen
Aber nicht nur das
Denkbar sei auch dass Elemente mit Ordnungszahlen Z > <num> also Transurane gebildet werden könnten
Tatsächlich synthetisierten Edwin M McMillan und Philip H Abelson erstmals im Jahr <num> die ersten nicht in der Natur vorkommenden Actinoid-Nuklide <num>U <num>Np und <num>Pu durch Beschuss von Uran mit Neutronen
Da im Jahr <num> noch kein Kernreaktor in Betrieb war konnten die Neutronen nur aus einer Neutronenquelle stammen
Obwohl bei dieser Kernreaktion letztlich auch ein Plutonium-Isotop entsteht konnte Plutonium wahrscheinlich wegen der geringen Ausbeute noch nicht nachgewiesen werden
Als Entdeckungsjahr von Plutonium gilt das Jahr <num> wie die Tabelle Entdeckung der Transurane zeigt
Plutonium wurde von den US-Amerikanern Glenn T Seaborg J W Kennedy E M McMillan Michael Cefola und Arthur Wahl entdeckt
Ende <num> stellten sie das Plutonium-Isotop <num>Pu durch Beschuss des Uran-Isotops <num>U mit Deuteronen her die in einem Zyklotron beschleunigt worden waren
Nachdem der eindeutige Nachweis für das Element <num> erbracht worden war erhielt es <num> den Namen Plutonium
Der Name lag nahe da die beiden Vorgängerelemente nach den Planeten Uranus und Neptun benannt worden waren
Details über die Kernreaktionen sind im Artikel
Plutonium
nachzulesen
Damit eine Transmutation mit elektrisch geladenen Teilchen wie Deuteronen stattfinden kann müssen diese Teilchen auf eine Energie beschleunigt werden die ausreicht um die Coulombbarriere von Urankernen zu überwinden oder diese zumindest zu durchtunneln
Das war erstmals mit einem Zyklotron möglich
Die erste wägbare Menge Plutonium von etwa <num> µg wurde <num> isoliert
DateiStagg Field reactorjpg Ende <num> wurde der erste Kernreaktor Chicago Pile in Betrieb genommen
Mit Kernreaktoren konnten vergleichsweise größere Mengen der Elemente Plutonium und Americium gewonnen werden die als Targetmaterial dienten
In Verbindung mit geladenen Teilchen mit beschleunigten α-Teilchen wurden dann die Nuklide der Elemente Curium Berkelium und Californium entdeckt
Der Vorteil des Verfahrens der Beschuss beschleunigter geladener Teilchen auf leichtere Actinoide ist dass auch massereiche neutronenarme Nuklide erhalten werden können die durch eine Neutronenbestrahlung nicht gebildet werden
Das effektivste Verfahren um synthetische Actinoide zu erzeugen ist die Transmutation von Uran- oder Thorium-Nukliden im Kernbrennstoff eines Kernreaktors durch Neutroneneinfang oder n<num>n-Reaktionen
Dieses Verfahren ist auf nicht allzu massereiche Actinoid-Nuklide beschränkt etwa bis zu Massenzahlen von A
<num>
Rechnerisch s u werden meist nur Nuklide bis A <
<num> einbezogen
Americium zum Beispiel wurde in einem Zweistufenprozess entdeckt
In der ersten Stufe werden synthetische Actinoide in einem Kernreaktor gebildet zum Beispiel <num>Pu
Plutonium wird nach Entnahme des Kernbrennstoffs durch Wiederaufarbeitung chemisch extrahiert
Dann wird das Plutonium erneut im Reaktor oder mittels einer Quelle mit Neutronen bestrahlt
Der gegenwärtig betriebene <num> MW High-Flux-Isotope Reactor am Oak Ridge National Laboratory in Tennessee USA ist auf die Herstellung von Transcuriumelementen Z > <num> speziell ausgelegt
Die massereichen Elemente Einsteinium und Fermium wurden durch den Test der ersten amerikanischen Wasserstoffbombe Ivy Mike am <num> November <num> auf dem Eniwetok-Atoll auf unsere Erde gebracht
Nur wenige Wochen später wurden sie im Lawrence Berkeley National Laboratory das an der geheimen Waffentwicklung nicht beteiligt war auf Filterpapieren und in Ablagerungen an Korallen völlig unerwartet entdeckt Bei der Wasserstoffbombenexplosion waren bis zu <num> Neutronen von einem Kern von <num>U eingefangen worden
Dieser Zwischenkern zerfiel sehr schnell über eine Kette von Betazerfällen in Nuklide der bis dahin unbekannten Elemente
Das Uran stammte aus der Ummantelung der Wasserstoffbombe die aus fünf Tonnen Natururan bestand
Aus Gründen der militärischen Geheimhaltung durften die Ergebnisse zunächst nicht publiziert werden
Um sich dennoch die Priorität der Entdeckungen der beiden neuen Elemente zu sichern wurden parallel erfolgreich Schwerionenreaktionen durchgeführt
<num>U wurde mit <num>N-Ionen die an einem Zyklotron erzeugt wurden bombardiert
Auf diesem Wege wurde zunächst Einsteinium synthetisiert und in der Publikation auf die Entdeckung von <num> verwiesen
Ähnlich verfuhr man mit Fermium das durch Beschuss mit <num>Pu mit <num>N-Ionen erzeugt wurde
Wie die Tabelle zeigt führten Schwerionenreaktionen auch zu den Elementen Mendelevium Nobelium und Lawrencium mit den Ordnungszahlen <num> bis <num>
Mit Schwerionenreaktionen wurden auch die Elemente mit höheren Ordnungszahlen synthetisiert
Bildung und Gewinnung im Kernreaktor
Der Kernreaktor nimmt was die Actinoide betrifft nicht nur deshalb eine herausragende Stellung ein weil er ohne Actinoide nicht betrieben werden könnte sondern weil es nur innerhalb eines Kernreaktors möglich ist größere wägbare Mengen von höheren Actinoid-Nukliden zu bilden
Dieser Abschnitt beschreibt welche Actinoid-Nuklide das sind und in welchem Massenanteil relativ zur ursprünglichen Schwermetallmasse sie gebildet werden
In einem Kernreaktor werden zu Beginn des Betriebs große Mengen von Actinoiden in Form von Kernbrennstoff eingebracht zum Beispiel mit <num>U angereichertes Uran
In einem Leistungsreaktor sind Aktinoidmassen in der Größenordnung von <num> t erthalten Aus diesem Kernbrennstoff werden neben der gewünschten Energiefreisetzung durch Kernspaltung synthetische höhere Actinoide durch Transmutation erzeugt
Actinoid-Nuklide in einem Kernreaktor
DateiActinide Buildup Chart <num>apng
Die Abbildung Nuklidkarte Bildung und Zerfall von Actinoiden in einem Kernreaktor ist eine Nuklidkarte in der Anordnung nach Segrè
Das heißt die Anzahl der Neutronen wird nach rechts zunehmend die Anzahl der Protonen nach oben zunehmend aufgetragen
Um die Zeichnungsfläche sinnvoll zu nutzen ist der Nuklidpfad am roten Punkt unterteilt
Jedes Quadrat der Abbildung stellt ein Actinoid-Nuklid dar das in einem Kernreaktor auftreten kann
Die Abbildung zeigt auch das Netzwerk von Bildung und Zerfall von Actinoid-Nukliden ausgelöst durch den Neutroneneinfang freier Neutronen und durch andere Kernreaktionen
Ein ähnliches Schema findet man in einer Arbeit aus dem Jahr <num>
Dort sind die Isotope von Thorium und Protactinium die zum Beispiel in Salzschmelzenreaktoren eine große Rolle spielen und die Isotope der Elemente Berkelium und Californium nicht enthalten
Die Bildung von Actinoid-Nukliden wird in erster Linie geprägt durch
Neutroneneinfang-Reaktionen nγ die in der Abbildung durch einen kurzen Rechtspfeil dargestellt sind
Berücksichtigt werden aber auch die n<num>n-Reaktionen und die seltener auftretenden gγ-Reaktionen die beide durch einen kurzen Linkspfeil markiert sind
Noch seltener und nur ausgelöst von schnellen Neutronen tritt die n<num>n-Reaktion auf die in der Abbildung mit einem Beispiel vertreten ist markiert durch einen langen Linkspfeil
Außer diesen neutronen- oder gammainduzierten Kernreaktionen wirkt sich auch die radioaktive Umwandlung der Actinoid-Nuklide auf den Nuklid-Bestand in einem Reaktor zu einem gegebenen Zeitpunkt Abbrandzustand aus
Diese Zerfallsarten sind in der Abbildung durch Diagonalpfeile markiert
Eine große Rolle für die Bilanz der Teilchendichten der Nuklide spielt der Beta-Minus-Zerfall markiert mit aufwärts zeigenden Diagonalpfeilen
Die Quadrate der Nuklide dieses Zerfallstyps haben in der Nuklidkarte eine hellblaue Füllfarbe
Zwei Nuklide sind nur zum Teil betaaktiv
Das rosafarben hinterlegte Nuklid <num>Np wandelt sich zu <num>
durch Elektroneneinfang und zu <num>
durch Beta-Minus-Zerfall hellblaue Ecke um
Ebenfalls zwei Zerfallsarten aber in nahezu umgekehrtem Verhältnis <num>
Beta-Minus-Zerfall <num>
Elektroneneinfang zeigt auch der Grundzustand von <num>Am rosa Ecke
Dieses Nuklid besitzt außerdem einen langlebigen metastabilen Zustand weiß hinterlegt der in der Regel durch <num>m<num>Am symbolisiert wird
Nuklide mit Positronen-Emissionen Beta-Plus-Zerfälle kommen in einem Kernreaktor nicht vor
Die Actinoid-Nuklide die sich unter Aussendung von α-Teilchen spontan umwandeln sind in der Nuklidkarte der Abbildung mit einer gelben Füllfarbe versehen worden
Der α-Zerfall spielt wegen der langen Halbwertszeiten T<num><num> bei Bildung und Zerfall der Actinoide während der Aufenthaltsdauer des Brennstoffs in einem Leistungsreaktor max ca <num> Jahre so gut wie keine Rolle
Ausnahmen sind die beiden relativ kurzlebigen Nuklide <num>Cm T<num><num>
<num> d und <num>Pu T<num><num>
<num> a
Nur für diese beiden Fälle ist der α-Zerfall durch lange abwärts zeigende Pfeile auf der Nuklidkarte markiert
Alle in der Abbildung angegebenen Halbwertszeiten sind die aktuellen evaluierten Nukleardaten NUBASE<num> abgerufen über den Nukleardaten-Viewer JANIS <num> Manche Halbwertszeiten sind gerundet
Zur Bedeutung von Abbrandprogrammen
Nur bei der ersten Inbetriebnahme des Reaktors kennt man die Zusammensetzung an Nukliden des Kernbrennstoffs genau
Es ist aber für jeden Zeitpunkt Abbrandzustand erforderlich grundlegende physikalische Größen wie den Neutronenfluss zu kennen
Zu den grundlegenden physikalischen Größen gehören auch die Teilchendichten und
Massendichten
aller im Reaktor gebildeten Actinoid-Nuklide
Das betrifft sowohl die der anfangs eingebrachten oder was davon noch vorhanden ist als auch die der im Reaktorbetrieb gebildeten Nuklide
Die tatsächlichen Teilchendichten und Massendichten der Actinoid-Nuklide in Abhängigkeit vom Abbrand im laufenden Betrieb zu messen ist nicht möglich
Erst nach der Entladung von Kernbrennstoff können diese Größen im Prinzip chemisch oder massenspektrometrisch untersucht werden
Das ist sehr aufwendig
Deshalb kommt einer Berechnung die den Betriebsablauf eines Kernreaktors begleitet ein hoher Stellenwert zu
Die Entwicklung der Teilchendichten und Massendichten von Nukliden in einem Kernreaktor wird in Abhängigkeit vom mittleren Abbrand engl Burnup Depletion vereinfacht in sog Abbrandprogrammen berechnet zum Beispiel
ORIGEN das erste weltweit verbreitete Programm zur Berechnung der Nuklidbildungen in Abhängigkeit vom Abbrand aus dem Jahr <num>
OrigenArp ein Programm zur Berechnung der Teilchendichten von Nukliden in Abhängigkeit vom Abbrand aus dem Jahr <num> das auch in das Programmsystem SCALE s u integriert ist
Für eine detaillierte Analyse werden hochkomplexe Reaktorprogrammsysteme Neutronen-Transportprogramme eingesetzt deren Leistungsumfang weit über den der zuvor genannten Programme hinausgeht und deren Anwendung eine lange Einarbeitungszeit erfordert zum Beispiel
SCALE ein großes Programmsystem für unterschiedliche neutronenphysikalische Berechnungen so u a auch für Abbrand- und Abschirmrechnungen
HELIOS ein Zell- und Abbrandprogrammsystem für Berechnungen in Neutronen-Transportnäherung
In letzteren Programmsystemen sind neben der anfänglichen Materialzusammensetzung auch geometrische Details von Reaktorbauteilen Zellen vorzugeben
Von Zeit zu Zeit werden solche Rechnungen mit den Ergebnissen von chemischer und massenspektrometrischer Analyse von entladenem Kernbrennstoff verglichen und gegebenenfalls genauere Messungen noch unsicherer Nukleardaten oder genauere Berechnungsmethoden angestoßen
Entwicklung der Massen der Actinoide im Kernreaktor
DateiActinide Masses <num>apng
Die Abbildung Entwicklung der Massen der Actinoiden
zeigt die Zu- oder Abnahme der Massen der <num> häufigsten Actinoid-Nuklide in einem Druckwasserreaktor der mit angereichertem Uran betrieben wird
Die Zahlenwerte wurden für eine größere Brennstoff-Zelle in Abhängigkeit vom Abbrand der spezifischen Energiefreisetzung berechnet
Die Berechnungen wurden im Jahr <num> mit dem Programmsystem HELIOS <num> ausgeführt Als Anfangsanreicherung des Nuklids <num>U wurde für dieses Beispiel <num>
gewählt
Die Punkte auf den Kurven der Abbildung markieren die Schrittweiten in der Abbrandrechnung
Die Schrittweite ist anfangs kleiner um auch diejenigen Spaltprodukte genauer zu erfassen die ihre Sättigung sehr schnell erreichen
Das trifft vor allem auf die starken Neutronenabsorber <num>Xe und <num>Sm zu
Eine ähnliche Abbildung eingeschränkt auf Uran- und Plutonium-Isotope findet man im Lehrbuch Neutron Physics von Paul Reuss
Die Masse jedes Nuklids wird durch die anfangs eingesetzte Masse an Schwermetall der Masse des Urans geteilt
Dargestellt sind die Massenanteile aller Nuklide die anfangs vorhanden waren drei Uran-Nuklide oder die mit einer Masse von mindestens <num> g pro eingesetzter Tonne Schwermetall nach einem Abbrand von maximal <num> MWdkg gebildet werden
Wie die Abbildung zeigt nehmen die Massen der drei anfangs vorhandenen Uranisotope <num>U <num>U und <num>U mit steigendem Abbrand monoton ab
Gleichzeitig nehmen die Massen der höheren Actinoide fast linear zu man beachte die logarithmische Skalierung der Ordinate
Von allen synthetischen Actinoiden nimmt die Masse des Nuklids <num>Pu am stärksten zu
Damit wächst auch die Anzahl der Spaltungen der Kerne des Nuklids <num>Pu
Ab einem Abbrand von ca <num> MWdkg nimmt dessen Masse wieder geringfügig ab
Würde man die Ordinate nach unten auf einen Massenanteil von mindestens <num> g pro eingesetzter Tonne Schwermetall herabsetzen kämen auf der Abbildung ab einem Abrand von ca <num> MWdkg das Nuklid <num>m<num>Am und ab einem Abrand von ca <num> MWdkg das Nuklid <num>Cm hinzu
Zusammengefasst In einem Druckwasserreaktor mit Uran-Brennelementen ohne MOX-Brennelemente werden aus den ursprünglich vorhandenen Actinoid-Nukliden <num>U und <num>U und einem geringen Anteil <num>U maximal <num> synthetische Actinoid-Nuklide innerhalb der üblichen Betriebszeiten gebildet deren Anteil größer als <num> g je Tonne Startmasse Schwermetall SM ist also <num> ppm Das sind die Nuklide <num>U <num>Np <num>Pu <num>Pu <num>Pu <num>Pu <num>Pu <num>Am <num>m<num>Am <num>Am <num>Cm <num>Cm und <num>Cm
Nuklide der Elemente Berkelium und Californium werden in einem Kernreaktor ebenfalls aber nur in sehr geringen Mengen gebildet
Die Actinoide können wie erwähnt durch chemische Aufarbeitung von entladenem Brennstoff extrahiert werden
Der Massenanteil von Curium zum Beispiel beträgt ca <num> bei einem gegenwärtig üblichen Abbrand von <num> MWdkg
wobei
die Masse des Curiums und
die Startmasse des Schwermetalls bedeuten
In einem Leistungsreaktor beträgt die anfängliche Schwermetallmasse ca
verteilt auf <num> Brennelemente
Angenommen alle Brennelemente seien entladen worden die diesen Abbrandzustand erreicht haben
Folglich ist die Masse des Curiums
Im gesamten Reaktor sind bei diesem mittleren Abbrand im Brennstoff ca <num> kg Curium entstanden
Anzumerken ist dass Leistungsreaktoren nicht betrieben werden um Actinoide zu gewinnen sondern um möglichst viele Actinoide zu spalten und Energie freizusetzen
Die Gesamtmasse aller Actinoide verringert sich durch Kernspaltung und zwar bei einem mittleren Abbrand von <num> MWdkg um insgesamt nur ca <num>
Diese findet sich in der Masse der Spaltprodukte wieder
Eigenschaften
Nukleare Eigenschaften
Die hervorgehobene Stellung der Actinoide man denke an ihre Bedeutung zur nuklearen Energiefreisetzung und an Kernwaffen werden durch die Eigenschaften ihrer Atomkerne determiniert
Alle Actinoid-Nuklide sind radioaktiv
Alle Actinoid-Nuklide sind neutroneninduziert spaltbar wenn auch mit sehr unterschiedlichen Wirkungsquerschnitten die außerdem sehr stark von der kinetischen Energie der Neutronen abhängen
Die vier Actinoid-Nuklide <num>Th <num>U <num>U und <num>U kommen natürlich vor
Ihre Quadrate sind in der obigen Nuklidkarte durch eine dickere Umrandung hervorgehoben
Mit Ausnahme von <num>U sind es primordiale Nuklide also Nuklide die schon bei der Entstehung der Erde vorhanden waren und noch nicht vollständig zerfallen sind
Das natürlich vorkommende extrem seltene primodiale Plutonium-Nuklid <num>Pu spielt im Kernreaktor keine Rolle
Sein Massenanteil in einigen Erzen liegt bei <num>-<num>
Im Jahr <num> waren mehr als <num> synthetisch erzeugte Actinoid-Nuklide bekannt Die meisten besitzen kurze Halbwertszeiten
Nur <num> haben Halbwertszeiten T<num><num> > <num> d
Von <num> Actinoid-Nukliden wird angenommen dass sie zu einer sich selbsterhaltenden Kettenreaktion fähig sind Andere Quellen gehen von weniger Actinoid-Nukliden aus für die es eine kritische Masse gibt
Für die sechs Actinoid-Nuklide <num>U <num>U <num>U <num>Pu <num>Pu und <num>Pu sind die Wirkungsquerschnitte relativ genau bekannt für alle anderen sind die Nukleardaten weniger genau Auf Kritikalitätsberechnungen wirken sich diese Ungenauigkeiten aber kaum aus
Je weniger Masse eines Nuklids sich im Kernreaktor befindet desto geringer ist die Auswirkung fehlerhafter Wirkungsquerschnitte auf solche Berechnungen
Klassische physikalische Eigenschaften
Einige physikalische Eigenschaften der Actinoid-Elemente findet man unter dem Stichwort der Namen der Elemente
Die Voraussetzung dafür dass klassische physikalische Eigenschaften zum Beispiel Kristallstruktur Massendichte Schmelzpunkt Siedepunkt oder elektrische Leitfähigkeit gemessen werden können ist es dass das Element in wägbaren Mengen gewonnen werden kann
Die Anzahl der tatsächlich gemessenen physikalischen Eigenschaften nimmt mit wachsender Ordnungszahl des Elements schnell ab
Zum Beispiel ist Californium das letzte Actinoid-Element von dem die Massendichte gemessen werden konnte
Zur Atomphysik der Actinoide ist anzumerken
Alle Actinoide sind wie oben erwähnt Schwermetalle
Einige Actinoide sind in feinverteiltem Zustand pyrophor
Actinoide gehören wie die Lanthanoide zu den inneren Übergangselementen oder
f-Block-Elementen da in diesen Reihen die f-Unterschalen mit Elektronen aufgefüllt werden
Chemische Eigenschaften
Alle Actinoide bilden dreifach geladene Ionen sie werden wie das Actinium als Untergruppe der <num> Nebengruppe aufgefasst
Die leichteren Actinoide Thorium bis Americium kommen in einer größeren Anzahl von Oxidationszahlen vor als die entsprechenden Lanthanoide
Farben der Actinoid-Ionen in wässriger Lösung
Verbindungen
Die Eigenschaften beziehen sich auf das häufigste bzw stabilste Isotop
Oxide
Die vierwertigen Oxide der Actinoide kristallisieren im kubischen Kristallsystem der Strukturtyp ist der CaF<sub><num><sub>-Typ Fluorit mit der
und den Koordinationszahlen An<num> O<num>
Halogenide
Die dreiwertigen Chloride der Actinoide kristallisieren im hexagonalen Kristallsystem
Die Struktur des UranIII-chlorids ist die Leitstruktur für eine Reihe weiterer Verbindungen
In dieser werden die Metallatome von je neun Chloratomen umgeben
Als Koordinationspolyeder ergibt sich dabei ein dreifach überkapptes trigonales Prisma wie es auch bei den späteren Actinoiden und den Lanthanoiden häufig anzutreffen ist
Es kristallisiert im hexagonalen Kristallsystem in der
und zwei Formeleinheiten pro Elementarzelle
Siehe auch
Lanthanoide
Einzelnachweise
Literatur
Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements
Springer Dordrecht <num> ISBN <num>-<num>-<num>-<num>
Harold W Kirby Lester R Morss Actinium S <num>-<num>
Mathias S Wickleder Blandine Fourest Peter K Dorhout Thorium S <num>-<num>
Boris F Myasoedov Harold W Kirby Ivan G Tananaev Protactinium S <num>-<num>
Ingmar Grenthe Janusz Drożdżynński Takeo Fujino Edgar C Buck Thomas E Albrecht-Schmitt Stephen F Wolf Uranium S <num>-<num>
Zenko Yoshida Stephen G Johnson Takaumi Kimura John R Krsul Neptunium S <num>-<num>
David L Clark Siegfried S Hecker Gordon D Jarvinen Mary P Neu Plutonium S <num>-<num>
Wolfgang H Runde Wallace W Schulz Americium S <num>-<num>
Gregg J Lumetta Major C Thompson Robert A Penneman P Gary Eller Curium S <num>-<num>
David E Hobart Joseph R Peterson Berkelium S <num>-<num>
Richard G Haire Californium S <num>-<num>
Richard G Haire Einsteinium S <num>-<num>
Robert J Silva Fermium Mendelevium Nobelium and Lawrencium S <num>-<num>
James E Huheey Anorganische Chemie
de Gruyter Berlin <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Norman N Greenwood Alan Earnshaw Chemie der Elemente
<num> Auflage
VCH Weinheim <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
dtv-Atlas zur Chemie Teil <num> <num> S <num>-<num>
Weblinks
Ida Noddack Das Periodische System der Elemente und seine Lücken in
Angewandte Chemie
<num> <num> <num> S <num>-<num> doi<num>ange<num>
E McMillan P H Abelson Radioactive Element <num> in
Physical Review
<num> <num> S <num>-<num> doi<num>PhysRev<num><num>
B B Cunningham L B Werner The First Isolation Of Plutonium In
Journal of the American Chemical Society <num> <num> <num> S <num>-<num> doi<num>ja<num>a<num>
High Flux Isotope Reactor Oak Ridge National Laboratory abgerufen am <num> November <num>
Albert Ghiorso
Chemical
Engineering News <num>
Die Schwermetallmasse ist nicht für jeden Leistungsreaktor leicht zu finden Im Artikel
wird die Schwermetallmasse mit <num> t angegeben verteilt auf <num> Brennelemente Das dürfte auch auf die anderen Leistungsreaktoren der Bauform
näherungsweise zutreffen
Janis <num> - Java-based Nuclear Data Information System
RK PWR-Calculations with the Code-System HELIOS <num> Studsvik <num> International Users Group Meeting Charlotte NC USA June <num>-<num> <num>
Die Zusammenfassung findet sich im INIS Repository httpsinisiaeaorgsearchsearchaspxorig_qRN<num> Wolfgang Liebscher Ekkehard Fluck Die systematische Nomenklatur der anorganischen Chemie Springer Berlin <num> ISBN <num>-<num>-<num>-X
Neil G Connelly Red Nomenclature of inorganic chemistry - IUPAC recommendations <num> Royal Society of Chemistry Cambridge <num> ISBN <num>-<num>-<num>-<num>
Guttmann Hengge Anorganische Chemie VCH Weinheim
New York
Basel
Cambridge <num>
dtv-Atlas zur Chemie <num> Teil <num> S <num>
Die Werte der atomaren und physikalischen Eigenschaften sind wenn nicht anders angegeben aus wwwwebelementscom entnommen
Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements Bd <num> <num> Springer ISBN <num>-<num>-<num>-<num>
Americium ist ein chemisches Element mit dem Elementsymbol Am und der Ordnungszahl <num> Im Periodensystem steht es in der Gruppe der Actinoide <num> Periode f-Block und zählt auch zu den Transuranen
Americium ist neben Europium das einzige nach einem Erdteil benannte Element
Es ist ein leicht verformbares radioaktives Metall silbrig-weißen Aussehens
Von Americium gibt es kein stabiles Isotop
Auf der Erde kommt es ausschließlich in künstlich erzeugter Form vor
Das Element wurde erstmals im Spätherbst <num> erzeugt die Entdeckung jedoch zunächst nicht veröffentlicht
Kurioserweise wurde seine Existenz in einer amerikanischen Radiosendung für Kinder durch den Entdecker Glenn T Seaborg den Gast der Sendung der Öffentlichkeit preisgegeben
Americium wird in Kernreaktoren gebildet eine Tonne abgebrannten Kernbrennstoffs enthält durchschnittlich etwa <num> g des Elements
Es wird als Quelle ionisierender Strahlung eingesetzt z B
in der Fluoreszenzspektroskopie und in Ionisationsrauchmeldern
Das Americiumisotop <num>Am wurde wegen seiner gegenüber Plutonium <num>Pu wesentlich längeren Halbwertszeit von <num> Jahren zur Befüllung von Radionuklidbatterien RTG für Raumsonden vorgeschlagen welche dann hunderte Jahre lang elektrische Energie zum Betrieb bereitstellen würden
Geschichte
DateiGlenn Seaborg - <num>jpg DateiBerkeley <num>-inch cyclotrongif
Americium wurde im Spätherbst <num> von Glenn T Seaborg Ralph A James Leon O Morgan und Albert Ghiorso im <num>-Zoll-Cyclotron an der Universität von Kalifornien in Berkeley sowie am metallurgischen Laboratorium der Universität von Chicago heute Argonne National Laboratory erzeugt
Nach Neptunium und Plutonium war Americium das vierte Transuran das seit dem Jahr <num> entdeckt wurde das um eine Ordnungszahl höhere Curium wurde als drittes schon im Sommer <num> erzeugt
Der Name für das Element wurde in Anlehnung zum Erdteil Amerika gewählt - in Analogie zu Europium dem Seltene-Erden-Metall das im Periodensystem genau über Americium steht The name americium after the Americas and the symbol Am are suggested for the element on the basis of its position as the sixth member of the actinide rare-earth series analogous to europium Eu of the lanthanide series
Zur Erzeugung des neuen Elements wurden in der Regel die Oxide der Ausgangselemente verwendet
Dazu wurde zunächst Plutoniumnitratlösung mit dem Isotop <num>Pu auf eine Platinfolie von etwa <num> cm<num> aufgetragen die Lösung danach eingedampft und der Rückstand dann zum Oxid PuO<num> geglüht
Nach dem Beschuss im Cyclotron wurde die Beschichtung mittels Salpetersäure gelöst anschließend wieder mit einer konzentrierten wässrigen Ammoniaklösung als Hydroxid ausgefällt der Rückstand wurde in Perchlorsäure gelöst
Die weitere Trennung erfolgte mit Ionenaustauschern
In ihren Versuchsreihen wurden der Reihe nach vier verschiedene Isotope erzeugt <num>Am <num>Am <num>Am und <num>Am
Als erstes Isotop isolierten sie <num>Am aus einer Plutonium-Probe die mit Neutronen bestrahlt wurde
Es zerfällt durch Aussendung eines α-Teilchens in <num>Np
Die Halbwertszeit dieses α-Zerfalls wurde zunächst auf <num>
<num> Jahre bestimmt der heute allgemein akzeptierte Wert ist <num> a
Die angegebenen Zeiten sind Halbwertszeiten
Als zweites Isotop wurde <num>Am durch erneuten Neutronenbeschuss des zuvor erzeugten <num>Am gefunden
Durch nachfolgenden raschen β-Zerfall entsteht dabei <num>Cm das zuvor schon entdeckte Curium
Die Halbwertszeit dieses β-Zerfalls wurde zunächst auf <num> Stunden bestimmt der heute als gültig ermittelte Wert beträgt <num> h
Erstmals öffentlich bekannt gemacht wurde die Entdeckung des Elements in der amerikanischen Radiosendung Quiz Kids am <num> November <num> durch Glenn T Seaborg noch vor der eigentlichen Bekanntmachung bei einem Symposium der American Chemical Society Einer der jungen Zuhörer fragte den Gast der Sendung Seaborg ob während des Zweiten Weltkrieges im Zuge der Erforschung von Nuklearwaffen neue Elemente entdeckt wurden
Seaborg bejahte die Frage und enthüllte dabei auch gleichzeitig die Entdeckung des nächsthöheren Elements Curium
Americium <num>Am und <num>Am und seine Produktion wurde später unter dem Namen Element <num> and method of producing said element patentiert wobei als Erfinder nur Glenn T Seaborg angegeben wurde
In elementarer Form wurde es erstmals im Jahr <num> durch Reduktion von AmericiumIII-fluorid mit Barium dargestellt
Vorkommen
Americiumisotope entstehen im r-Prozess in Supernovae und kommen auf der Erde wegen ihrer im Vergleich zum Alter der Erde zu geringen Halbwertszeit nicht natürlich vor
Heutzutage wird jedoch Americium als Nebenprodukt in Kernkraftwerken erbrütet das Americiumisotop <num>Am entsteht als Zerfallsprodukt u a
in abgebrannten Brennstäben aus dem Plutoniumisotop <num>Pu
Eine Tonne abgebrannten Kernbrennstoffs enthält durchschnittlich etwa <num> g verschiedener Americiumisotope Es handelt sich dabei hauptsächlich um die α-Strahler <num>Am und <num>Am die aufgrund ihrer relativ langen Halbwertszeiten in der Endlagerung unerwünscht sind und deshalb zum Transuranabfall zählen
Eine Verminderung der Langzeitradiotoxizität in nuklearen Endlagern wäre durch Abtrennung langlebiger Isotope aus abgebrannten Kernbrennstoffen möglich
Zur Beseitigung des Americiums wird derzeit die Partitioning
Transmutation-Strategie untersucht
Gewinnung und Darstellung
Gewinnung von Americiumisotopen
Americium fällt in geringen Mengen in Kernreaktoren an
Es steht heute in Mengen von wenigen Kilogramm zur Verfügung
Durch die aufwändige Gewinnung aus abgebrannten Brennstäben hat es einen sehr hohen Preis
Seit der Markteinführung <num> soll der Preis für AmericiumIV-oxid mit dem Isotop <num>Am bei etwa <num> US-Dollar pro Gramm liegen Das Americiumisotop <num>Am entsteht in geringeren Mengen im Reaktor aus <num>Am und ist deshalb mit <num> US-Dollar pro Milligramm <num>Am noch wesentlich teurer
Americium wird über das Plutoniumisotop <num>Pu in Kernreaktoren mit hohem <num>U-Anteil zwangsläufig erbrütet da es aus diesem durch Neutroneneinfang und zwei anschließende β-Zerfälle über <num>U und <num>Np entsteht
Die angegebenen Zeiten sind Halbwertszeiten
Danach wird wenn es nicht zur Kernspaltung kommt aus dem <num>Pu neben anderen Nukliden durch stufenweisen Neutroneneinfang nγ und anschließenden β-Zerfall <num>Am oder <num>Am erbrütet
Das Plutonium welches aus abgebrannten Brennstäben von Leistungsreaktoren gewonnen werden kann besteht zu etwa <num>
aus dem Isotop <num>Pu Deshalb erreichen erst <num> Jahre nachdem der Brutprozess beendet wurde die abgebrannten Brennstäbe ihren Maximalgehalt von <num>Am danach nimmt der Gehalt wieder langsamer als der Anstieg ab
Aus dem so entstandenen <num>Am kann durch weiteren Neutroneneinfang im Reaktor <num>Am entstehen
Bei Leichtwasserreaktoren soll aus dem <num>Am zu <num>
<num>Am und zu <num>
<num>m Am entstehen
zu <num>
zu <num>
Für die Erbrütung von <num>Am ist ein vierfacher Neutroneneinfang des <num>Pu erforderlich
Darstellung elementaren Americiums
Metallisches Americium kann durch Reduktion aus seinen Verbindungen erhalten werden
Zuerst wurde AmericiumIII-fluorid zur Reduktion verwendet
Dieses wird hierzu in wasser- und sauerstofffreier Umgebung in Reaktionsapparaturen aus Tantal und Wolfram mit elementarem Barium zur Reaktion gebracht
<num> AmF<num>
<num> Ba -> <num> Am
<num> BaF<num>
Auch die Reduktion von AmericiumIV-oxid mittels Lanthan oder Thorium ergibt metallisches Americium
<num> AmO<num>
<num> La -> <num> Am
<num> La<num>O<num>
Eigenschaften
DateiAmericium microscopejpg DateiClosest packing ABACpng Im Periodensystem steht das Americium mit der Ordnungszahl <num> in der Reihe der Actinoide sein Vorgänger ist das Plutonium das nachfolgende Element ist das Curium
Sein Analogon in der Reihe der Lanthanoiden ist das Europium
Physikalische Eigenschaften
Americium ist ein radioaktives Metall
Frisch hergestelltes Americium ist ein silberweißes Metall welches jedoch bei Raumtemperatur langsam matt wird
Es ist leicht verformbar
Sein Schmelzpunkt beträgt <num> C der Siedepunkt liegt bei <num> C
Die Dichte beträgt <num> gcm-<num>
Es tritt in zwei Modifikationen auf
Die bei Standardbedingungen stabile Modifikation α-Am kristallisiert im hexagonalen Kristallsystem in der
mit den Gitterparametern a
<num> pm und c
<num> pm sowie vier Formeleinheiten pro Elementarzelle
Die Kristallstruktur besteht aus einer doppelt-hexagonal dichtesten Kugelpackung d hcp mit der Schichtfolge ABAC und ist damit isotyp zur Struktur von α-La
Bei hohem Druck geht α-Am in β-Am über
Die β-Modifikation kristallisiert im kubischen Kristallsystem in der Raumgruppe
mit dem Gitterparameter a
<num> pm
was einem kubisch flächenzentrierten Gitter fcc beziehungsweise einer kubisch dichtesten Kugelpackung mit der Stapelfolge ABC entspricht
Die Lösungsenthalpie von Americium-Metall in Salzsäure bei Standardbedingungen beträgt -<num>
<num> kJmol-<num>
Ausgehend von diesem Wert erfolgte die erstmalige Berechnung der Standardbildungsenthalpie Δf H <num> von Am<num> aq auf -<num>
<num> kJmol-<num> und des Standardpotentials Am<num>
Am<num> auf -<num>
<num> V
Chemische Eigenschaften
Americium ist ein sehr reaktionsfähiges Element das schon mit Luftsauerstoff reagiert und sich gut in Säuren löst
Gegenüber Alkalien ist es stabil
Die stabilste Oxidationsstufe für Americium ist <num> die AmIII-Verbindungen sind gegen Oxidation und Reduktion sehr stabil
Mit dem Americium liegt der erste Vertreter der Actinoiden vor der in seinem Verhalten eher den Lanthanoiden ähnelt als den d-Block-Elementen
Es ist auch in den Oxidationsstufen <num> sowie <num> <num> <num> und <num> zu finden
Je nach Oxidationszahl variiert die Farbe von Americium in wässriger Lösung ebenso wie in festen VerbindungenAm<num> gelbrosa Am<num> gelbrot AmVO<num>
gelb AmVIO<num> <num> zitronengelb AmVIIO<num> <num>- dunkelgrün
Im Gegensatz zum homologen Europium - Americium hat eine zu Europium analoge Elektronenkonfiguration - kann Am<num> in wässriger Lösung nicht zu Am<num> reduziert werden
Verbindungen mit Americium ab Oxidationszahl <num> aufwärts sind starke Oxidationsmittel vergleichbar dem Permanganat-Ion MnO<num> - in saurer Lösung
Die in wässriger Lösung nicht beständigen Am<num>-Ionen lassen sich nur noch mit starken Oxidationsmitteln aus AmIII darstellen
In fester Form sind zwei Verbindungen des Americiums in der Oxidationsstufe <num> bekannt AmericiumIV-oxid AmO<num> und AmericiumIV-fluorid AmF<num>
Der fünfwertige Oxidationszustand wurde beim Americium erstmals <num> beobachtet In wässriger Lösung liegen primär AmO<num> -Ionen sauer oder AmO<num> --Ionen alkalisch vor die jedoch instabil sind und einer raschen Disproportionierung unterliegen
<num> AmO<num>
<num> H -> <num> AmO<num><num>
Am<num>
<num> H<num>O
Zunächst ist von einer Disproportionierung zur Oxidationsstufe <num> und <num> auszugehen
<num> Am V -> Am VI
Am IV
Etwas beständiger als AmIV und AmV sind die AmericiumVI-Verbindungen
Sie lassen sich aus AmIII durch Oxidation mit Ammoniumperoxodisulfat in verdünnter Salpetersäure herstellen
Der typische rosafarbene Ton verschwindet in Richtung zu einer starken Gelbfärbung Zudem kann die Oxidation mit SilberI-oxid in Perchlorsäure quantitativ erreicht werden In Natriumcarbonat- oder Natriumhydrogencarbonat-Lösungen ist eine Oxidation mit Ozon oder Natriumperoxodisulfat gleichfalls möglich
Americium III in <num>M Na<num>CO<num>jpgAmericiumIIIin <num> M Na<num>CO<num>-Lösung Americium IV in <num>M Na<num>CO<num>jpgAmericiumIVin <num> M Na<num>CO<num>-Lösung Americium IV VI in <num>M Na<num>CO<num>jpgAmericiumIV und VIin <num> M Na<num>CO<num>-Lösung
Biologische Aspekte
Eine biologische Funktion des Americiums ist nicht bekannt Vorgeschlagen wurde der Einsatz immobilisierter Bakterienzellen zur Entfernung von Americium und anderen Schwermetallen aus Fließgewässern
So können Enterobakterien der Gattung
Citrobacter
durch die Phosphatase aktivität in ihrer Zellwand bestimmte Americiumnuklide aus wässriger Lösung ausfällen und als Metall-Phosphat-Komplex binden Ferner wurden die Faktoren untersucht die die Biosorption und Bioakkumulation des Americiums durch Bakterien
und Pilze beeinflussen
Spaltbarkeit
Das Isotop <num>m<num>Am hat mit rund <num> barn den höchsten bisher <num><num> gemessenen thermischen Spaltquerschnitt Damit geht eine kleine kritische Masse einher weswegen <num>m<num>Am als Spaltmaterial vorgeschlagen wurde um beispielsweise Raumschiffe mit Kernenergieantrieb anzutreiben
Dieses Isotop eignet sich prinzipiell auch zum Bau von Kernwaffen
Die kritische Masse einer reinen <num>m<num>Am-Kugel beträgt etwa <num>-<num> kg
Die Unsicherheiten der verfügbaren Wirkungsquerschnitte lassen derzeit keine genauere Aussage zu
Mit Reflektor beträgt die kritische Masse noch etwa <num>-<num> kg In wässriger Lösung wird sie nochmals stark herabgesetzt
Auf diese Weise ließen sich sehr kompakte Sprengköpfe bauen
Nach öffentlichem Kenntnisstand wurden bisher keine Kernwaffen aus <num>m<num>Am gebaut was mit der geringen Verfügbarkeit und dem hohen Preis begründet werden kann
Aus denselben Gründen wird <num>m<num>Am auch nicht als Kernbrennstoff in Kernreaktoren eingesetzt obwohl es dazu prinzipiell sowohl in thermischen als auch in schnellen Reaktoren geeignet wäre Auch die beiden anderen häufiger verfügbaren Isotope <num>Am und <num>Am können in einem schnellen Reaktor eine Kettenreaktion aufrechterhalten
Die kritischen Massen sind hier jedoch sehr hoch
Sie betragen unreflektiert <num>-<num> kg bei <num>Am und <num> kg bei <num>Am so dass sich durch die Verwendung keine Vorteile gegenüber herkömmlichen Spaltstoffen ergeben
Entsprechend ist Americium rechtlich nach
Abs <num> des Atomgesetzes nicht den Kernbrennstoffen zugeordnet
Es existieren jedoch Vorschläge sehr kompakte Reaktoren mit einem Americium-Inventar von lediglich knapp <num> g zu konstruieren die in Krankenhäusern als Neutronenquelle für die Neutroneneinfangtherapie verwendet werden können
Isotope
Von Americium sind <num> Isotope und <num> Kernisomere mit Halbwertszeiten zwischen Bruchteilen von Mikrosekunden und <num> Jahren bekannt
Es gibt zwei langlebige α-strahlende Isotope <num>Am mit <num> und <num>Am mit <num> Jahren Halbwertszeit
Außerdem hat das Kernisomer <num>m<num>Am mit <num> Jahren eine lange Halbwertszeit
Die restlichen Kernisomere und Isotope haben mit <num> µs bei <num>m<num>Am bis <num> Stunden bei <num>Am kurze Halbwertszeiten
<num>Am ist das am häufigsten erbrütete Americiumisotop und liegt auf der Neptunium-Reihe
Es zerfällt mit einer Halbwertszeit von <num> Jahren mit einem α-Zerfall zu <num>Np
<num>Am gibt nur mit einer Wahrscheinlichkeit von <num>
die gesamte Zerfallsenergie mit dem α-Teilchen ab sondern emittiert meistens noch ein oder mehrere Gammaquanten
<num>Am ist kurzlebig und zerfällt mit einer Halbwertszeit von <num> h zu <num>
durch β-Zerfall zu <num>Cm und zu <num>
durch Elektroneneinfang zu <num>Pu
Das <num>Cm zerfällt zu <num>Pu und dieses weiter zu <num>U das auf der Uran-Radium-Reihe liegt
Das <num>Pu zerfällt über die gleiche Zerfallskette wie <num>Pu
Während jedoch <num>Pu als Seitenarm beim <num>U auf die Zerfallskette kommt steht <num>Pu noch vor dem <num>U <num>Pu zerfällt durch α-Zerfall in <num>U den Beginn der natürlichen Uran-Radium-Reihe
<num>m<num>Am zerfällt mit einer Halbwertszeit von <num> Jahren zu <num>
durch Innere Konversion zu <num>Am und zu <num>
durch α-Zerfall zu <num>Np
Dieses zerfällt zu <num>Pu und dann weiter zu <num>U das auf der Uran-Radium-Reihe liegt
<num>Am ist mit einer Halbwertszeit von <num> Jahren das langlebigste Americiumisotop
Es geht zunächst durch α-Strahlung in <num>Np über das durch β-Zerfall weiter zu <num>Pu zerfällt
Das <num>Pu zerfällt durch α-Strahlung zu Uran <num>U dem offiziellen Anfang der Uran-Actinium-Reihe
Die Americiumisotope mit ungerader Neutronenzahl also gerader Massenzahl sind gut durch thermische Neutronen spaltbar
Liste der Americiumisotope
Verwendung
Für die Verwendung von Americium sind vor allem die beiden langlebigsten Isotope <num>Am und <num>Am von Interesse
In der Regel wird es in Form des Oxids AmO<num> verwendet
DateiAmericio-alarmajpg
Ionisationsrauchmelder
Die α-Strahlung des <num>Am wird in Ionisationsrauchmeldern genutzt Es wird gegenüber <num> Ra bevorzugt da es vergleichsweise wenig γ-Strahlung emittiert
Dafür muss aber die Aktivität gegenüber Radium ca das Fünffache betragen
Die Zerfallsreihe von <num>Am endet für den Verwendungszeitraum quasi direkt nach dessen α-Zerfall bei <num> Np das eine Halbwertszeit von rund <num> Millionen Jahren besitzt
Radionuklidbatterien
<num>Am wurde wegen seiner gegenüber <num>Pu wesentlich längeren Halbwertszeit zur Befüllung von Radionuklidbatterien RTG von Raumsonden vorgeschlagen
Dank seiner Halbwertszeit von <num> Jahren könnte ein RTG mit <num>Am-Füllung hunderte Jahre lang - anstatt nur einige Jahrzehnte wie mit einer <num>Pu-Füllung - elektrische Energie zum Betrieb einer Raumsonde bereitstellen Es soll voraussichtlich in den Radionuklidbatterien zum Einsatz kommen deren Entwicklung die ESA erwägt und deren Entwicklung in den <num>er-Jahren abgeschlossen werden könnte
Neutronenquellen
<num>Am als Oxid mit Beryllium verpresst stellt eine Neutronenquelle dar die beispielsweise für radiochemische Untersuchungen eingesetzt wird Hierzu wird der hohe Wirkungsquerschnitt des Berylliums für αn-Kernreaktionen ausgenutzt wobei das Americium als Produzent der α-Teilchen dient
Die entsprechenden Reaktionsgleichungen lauten
Derartige Neutronenquellen kommen beispielsweise in der Neutronenradiographie und -tomographie zum Einsatz
Ionisator
DateiAm-<num> Brushjpg Neben dem häufig verwendeten <num>Po als Ionisator zur Beseitigung von unerwünschter elektrostatischer Aufladung kam auch <num>Am zum Einsatz
Dazu wurde z B
die Quelle am Kopf einer Bürste montiert mit der man langsam über die zu behandelnden Oberflächen strich und dadurch eine Wiederverschmutzung durch elektrostatisch angezogene Staubpartikel vermeiden konnte
Herstellung anderer Elemente
Americium ist Ausgangsmaterial zur Erzeugung höherer Transurane und auch der Transactinoide
Aus <num>Am entsteht zu <num>
Curium <num>Cm und zu <num>
Plutonium <num>Pu
Im Kernreaktor wird zwangsläufig in geringen Mengen durch Neutroneneinfang aus <num>Am das <num>Am erbrütet das durch β-Zerfall zum Curiumisotop <num>Cm zerfällt
In Teilchenbeschleunigern führt zum Beispiel der Beschuss von <num>Am mit Kohlenstoffkernen <num>C beziehungsweise Neonkernen <num>Ne zu den Elementen Einsteinium <num>Es beziehungsweise Dubnium <num>Db
Spektrometer
Mit seiner intensiven Gammastrahlungs-Spektrallinie bei <num> keV eignet sich <num>Am gut als Strahlenquelle für die Röntgen-Fluoreszenzspektroskopie
Dies wird auch zur Kalibrierung von Gammaspektrometern im niederenergetischen Bereich verwendet da die benachbarten Linien vergleichsweise schwach sind und so ein einzeln stehender Peak entsteht
Zudem wird der Peak nur vernachlässigbar durch das Compton-Kontinuum höherenergetischer Linien gestört da diese ebenfalls höchstens mit einer um mindestens drei Größenordnungen geringeren Intensität auftreten
Sicherheitshinweise und Gefahren
Einstufungen nach der CLP-Verordnung liegen nicht vor weil diese nur die chemische Gefährlichkeit umfassen welche eine völlig untergeordnete Rolle gegenüber den auf der Radioaktivität beruhenden Gefahren spielt
Eine chemische Gefahr liegt überhaupt nur dann vor wenn es sich um eine dafür relevante Stoffmenge handelt
Da von Americium nur radioaktive Isotope existieren darf es selbst sowie seine Verbindungen nur in geeigneten Laboratorien unter speziellen Vorkehrungen gehandhabt werden
Die meisten gängigen Americiumisotope sind α-Strahler weshalb eine Inkorporation unbedingt vermieden werden muss
Das breite Spektrum der hieraus resultierenden meist ebenfalls radioaktiven Tochternuklide stellt ein weiteres Risiko dar das bei der Wahl der Sicherheitsvorkehrungen berücksichtigt werden muss <num>Am gibt beim radioaktiven Zerfall große Mengen relativ weicher Gammastrahlung ab die sich gut abschirmen lässt
Nach Untersuchungen des Forschers Arnulf Seidel vom Institut für Strahlenbiologie des Kernforschungszentrums Karlsruhe erzeugt Americium wie Plutonium bei Aufnahme in den Körper mehr Knochentumore als dieselbe Dosis Radium
Die biologische Halbwertszeit von <num>Am beträgt in den Knochen <num> Jahre und in der Leber <num> Jahre
In den Gonaden verbleibt es dagegen offensichtlich dauerhaft
Verbindungen
Kategorie
Oxide
Von Americium existieren Oxide der Oxidationsstufen <num> Am<num>O<num> und <num> AmO<num>
AmericiumIII-oxid Am<num>O<num> ist ein rotbrauner Feststoff und hat einen Schmelzpunkt von <num> C
AmericiumIV-oxid AmO<num> ist die wichtigste Verbindung dieses Elements
Nahezu alle Anwendungen dieses Elements basieren auf dieser Verbindung
Sie entsteht unter anderem implizit in Kernreaktoren beim Bestrahlen von Urandioxid UO<num> bzw Plutoniumdioxid PuO<num> mit Neutronen
Es ist ein schwarzer Feststoff und kristallisiert - wie die anderen ActinoidenIV-oxide - im kubischen Kristallsystem in der Fluorit-Struktur
Halogenide
Halogenide sind für die Oxidationsstufen <num> <num> und <num> bekannt Die stabilste Stufe <num> ist für sämtliche Verbindungen von Fluor bis Iod bekannt und in wässriger Lösung stabil
AmericiumIII-fluorid AmF<num> ist schwerlöslich und kann durch die Umsetzung einer wässrigen Americiumlösung mit Fluoridsalzen im schwach Sauren durch Fällung hergestellt werden
Das tetravalente AmericiumIV-fluorid AmF<num> ist durch die Umsetzung von AmericiumIII-fluorid mit molekularem Fluor zugänglich
In der wässrigen Phase wurde das vierwertige Americium auch beobachtet
AmericiumIII-chlorid AmCl<num> bildet rosafarbene hexagonale Kristalle
Seine Kristallstruktur ist isotyp mit UranIII-chlorid
Der Schmelzpunkt der Verbindung liegt bei <num> C Das Hexahydrat AmCl<num><num> H<num>O weist eine monokline Kristallstruktur auf
Durch Reduktion mit Na-Amalgam aus AmIII-Verbindungen sind AmII-Salze zugänglich die schwarzen Halogenide AmCl<num> AmBr<num> und AmI<num>
Sie sind sehr sauerstoffempfindlich und oxidieren in Wasser unter Freisetzung von Wasserstoff zu AmIII-Verbindungen
Chalkogenide und Pentelide
Von den Chalkogeniden sind bekannt das Sulfid AmS<num> zwei Selenide AmSe<num> und Am<num>Se<num>
und zwei Telluride Am<num>Te<num> und AmTe<num>
Die Pentelide des Americiums <num>Am des Typs AmX sind für die Elemente Phosphor Arsen Antimon und Bismut dargestellt worden
Sie kristallisieren im NaCl-Gitter
Silicide und Boride
Americiummonosilicid AmSi und Americiumdisilicid AmSix mit <num> < x < <num> wurden durch Reduktion von AmericiumIII-fluorid mit elementaren Silicium im Vakuum bei <num> C AmSi und <num>-<num> C AmSix dargestellt
AmSi ist eine schwarze Masse isomorph mit LaSi
AmSix ist eine hellsilbrige Verbindung mit einem tetragonalen Kristallgitter
Boride der Zusammensetzungen AmB<num> und AmB<num> sind gleichfalls bekannt
Metallorganische Verbindungen
Analog zu Uranocen einer Organometallverbindung in der Uran von zwei Cyclooctatetraen-Liganden komplexiert ist wurden die entsprechenden Komplexe von Thorium Protactinium Neptunium Plutonium und auch des Americiums η<num>-C<num>H<num><num>Am dargestellt
Einzelnachweise
Literatur
Wolfgang H Runde Wallace W Schulz
in Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements Springer Dordrecht <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> doi<num><num>-<num>-<num>-<num>_<num>
Gmelins Handbuch der anorganischen Chemie
System Nr <num> Transurane Teil A <num> I S <num>-<num> Teil A <num> II S <num> <num>-<num> <num>-<num> Teil A <num> S <num>-<num> <num>-<num> <num>-<num> Teil B <num> S <num>-<num>
Weblinks
Rachel Sheremeta Pepling
Chemical
Engineering News <num>
G T Seaborg R A James L O Morgan The New Element Americium Atomic Number <num> NNES PPR National Nuclear Energy Series Plutonium Project Record Vol <num> B The Transuranium Elements Research Papers Paper No <num> McGraw-Hill Book Co Inc New York <num> Abstract Maschinoskript Januar <num> K Street Jr A Ghiorso G T Seaborg The Isotopes of Americium in
Physical Review
<num> <num> <num> S <num>-<num> doi<num>PhysRev<num> Maschinoskript <num> April <num> Übersetzung Der Name Americium nach den beiden Amerikas und das Symbol Am werden für das Element vorgeschlagen - basierend auf seiner Position als sechstes Mitglied der Actinoid-Seltenerdmetalle-Serie in Analogie zum Europium Eu aus der Lanthanoiden-Serie G Audi O Bersillon J Blachot A H Wapstra The NUBASE evaluation of nuclear and decay properties in
Nuclear Physics A
<num> <num> S <num>-<num>
<num> MB Rachel Sheremeta Pepling
Chemical
Engineering News <num> Edgar F Westrum Jr LeRoy Eyring The Preparation and Some Properties of Americium Metal in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> Klaus Hoffmann Kann man Gold machen Gauner Gaukler und Gelehrte Aus der Geschichte der chemischen Elemente Urania-Verlag Leipzig Jena Berlin <num>
S <num> L H Baetsle
PDF <num> MB September <num> Gabriele Fioni Michel Cribier Frédéric Marie textSmoke Detectors and Americium urlhttpwwwworld-nuclearorginfoinf<num>html wayback<num> archiv-bot<num>-<num>-<num> <num><num> InternetArchiveBot
Informationen zum Element Americium bei wwwspeclabcom engl Zugriff <num> Oktober <num>
Akihiro Sasahara Tetsuo Matsumura Giorgos Nicolaou Dimitri Papaioannou Neutron and Gamma Ray Source Evaluation of LWR High Burn-up UO<num> and MOX Spent Fuels in
Journal of Nuclear Science and Technology
<num> <num> <num> S <num>-<num> doi<num><num><num> Gmelins Handbuch der anorganischen Chemie
System Nr <num> Transurane Teil B <num> S <num>-<num> W Z Wade T Wolf Preparation and Some Properties of Americium Metal in
J Inorg Nucl Chem
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> D B McWhan B B Cunningham J C Wallmann Crystal Structure Thermal Expansion and Melting Point of Americium Metal in
J Inorg Nucl Chem
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> J U Mondal D L Raschella R G Haire J R Peterson The Enthalpy of Solution of <num>Am Metal and the Standard Enthalpy of Formation of Am<num>aq in
Thermochim Acta
<num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> L B Werner I Perlman The Pentavalent State of Americium in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> G R Hall T L Markin The Self-reduction of AmericiumV and VI and the Disproportionation of AmericiumV in Aqueous Solution in
J Inorg Nucl Chem
<num> <num> <num>-<num> S <num>-<num> doi<num><num>-<num><num><num>-<num> James S Coleman The Kinetics of the Disproportionation of AmericiumV in
Inorg Chem
<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num> L B Asprey S E Stephanou R A Penneman A New Valence State of Americium AmVI in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> L B Asprey S E Stephanou R A Penneman Hexavalent Americium in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> J S Coleman T K Keenan L H Jones W T Carnall R A Penneman Preparation and Properties of AmericiumVI in Aqueous Carbonate Solutions in
Inorg Chem
<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num>
L E Macaskie B C Jeong M R Tolley Enzymically Accelerated Biomineralization of Heavy Metals Application to the Removal of Americium and Plutonium from Aqueous Flows in
FEMS Microbiol Rev
<num> <num> <num> S <num>-<num> PMID <num> E A Wurtz T H Sibley W R Schell Interactions of Escherichia coli and Marine Bacteria with <num>Am in Laboratory Cultures in
Health Phys
<num> <num> <num> S <num>-<num> PMID <num> A J Francis J B Fillow C J Dodge M Dunn K Mantione B A Strietelmeier M E Pansoy-Hjelvik H W Papenguth Role of Bacteria as Biocolloids in the Transport of Actinides from a Deep Underground Radioactive Waste Repository in
Radiochimica Acta
<num> <num> S <num>-<num> Abstract und PDF-Download N Liu Y Yang S Luo T Zhang J Jin J Liao X Hua Biosorption of <num>Am by Rhizopus arrihizus Preliminary Investigation and Evaluation in
Appl Radiat Isot
<num> <num> <num> S <num>-<num> PMID <num> G Pfennig H Klewe-Nebenius W Seelmann-Eggebert Hrsg Karlsruher Nuklidkarte
<num> Auflage <num> Science daily
<num> Januar <num> H Dias N Tancock A Clayton Critical Mass Calculations for <num>Am <num>mAm and <num>Am in
Nippon Genshiryoku Kenkyujo JAERI Conf
<num> S <num>-<num> Abstract PDF Y Ronen M Aboudy D Regev A novel method for energy production using <num>mAm as a nuclear fuel in
Nuclear technology
<num> <num> <num> S <num>-<num> Abstract Institut de Radioprotection et de Sûreté Nucléaire Evaluation of nuclear criticality safety data and limits for actinides in transport S <num>
Y Ronen M Aboudy D Regev Homogeneous <num>mAm-Fueled Reactor for Neutron Capture Therapy in
Nuclear Science and Engineering
<num> <num> <num> S <num>-<num> Abstract
PDF <num> kB letzte Seite Stephen Clark
in
Spaceflight Now
<num> Juli <num> NA Nuclear Data Viewer <num> NNDC abgefragt am <num> September <num> Sucheingabe Lenntech
Abschnitt <num> Franz Frisch Klipp und klar <num> x Energie Bibliographisches Institut AG Mannheim <num> ISBN <num>-<num>-<num>-X S <num>
L B Asprey T K Keenan F H Kruse Crystal Structures of the Trifluorides Trichlorides Tribromides and Triiodides of Americium and Curium in
Inorg Chem
<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num> L B Asprey New Compounds of Quadrivalent Americium AmF<num> KAmF<num>
in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> L B Asprey R A Penneman First Observation of Aqueous Tetravalent Americium in
J Am Chem Soc
<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> John H Burns Joseph Richard Peterson The Crystal Structures of Americium Trichloride Hexahydrate and Berkelium Trichloride Hexahydrate in
Inorg Chem
<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num> D Damien J Jove Americium Disulfide and Diselenide in
Inorg Nucl Chem Lett
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> J W Roddy Americium Metallides AmAs AmSb AmBi Am<num>Se<num> and AmSe<num>
in
J Inorg Nucl Chem
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> D Damien Americium Tritelluride and Ditelluride in
Inorg Nucl Chem Lett
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> J P Charvillat D Damien Americium Monoarsenide in
Inorg Nucl Chem Lett
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> F Weigel F D Wittmann R Marquart Americium Monosilicide and Disilicide in
Journal of the Less Common Metals
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-X Harry A Eick R N R Mulford Americium and Neptunium Borides in
J Inorg Nucl Chem
<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-X Christoph Elschenbroich Organometallchemie <num> Auflage Wiesbaden <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>
DateiHelium atom QM DEsvg DateiKovalente Atomradien auf Basis der Cambridge Structural Databasesvg Atome von
átomos unteilbar sind die Bausteine aus denen alle festen flüssigen oder gasförmigen Stoffe bestehen
Alle Materialeigenschaften dieser Stoffe sowie ihr Verhalten in chemischen Reaktionen werden durch die Eigenschaften und die räumliche Anordnung der Atome aus denen sie aufgebaut sind festgelegt
Jedes Atom gehört zu einem bestimmten chemischen Element und bildet dessen kleinste Einheit
Zurzeit sind <num> Elemente bekannt von denen etwa <num> auf der Erde natürlich vorkommen
Atome verschiedener Elemente unterscheiden sich in ihrer Größe und Masse und vor allem in ihrer Fähigkeit mit anderen Atomen chemisch zu reagieren und sich zu Molekülen oder festen Körpern zu verbinden
Die Durchmesser von Atomen liegen im Bereich von <num>
<num>-<num> m Helium bis <num>
<num>-<num> m Cäsium ihre Massen in einem Bereich von <num>
<num>-<num> kg Wasserstoff bis knapp <num> <num>-<num> kg die derzeit schwersten synthetisch hergestellten Kerne
Atome sind nicht unteilbar wie zum Zeitpunkt der Namensgebung angenommen sondern zeigen einen wohlbestimmten Aufbau aus noch kleineren Teilchen
Sie bestehen aus einem Atomkern und einer Atomhülle
Der Atomkern hat einen Durchmesser von etwa einem Zehn- bis Hunderttausendstel des gesamten Atomdurchmessers enthält jedoch über <num> Prozent der Atommasse
Er besteht aus positiv geladenen Protonen und einer Anzahl von etwa gleich schweren elektrisch neutralen Neutronen
Diese Nukleonen sind durch die starke Wechselwirkung aneinander gebunden
Die Hülle besteht aus negativ geladenen Elektronen
Sie trägt mit weniger als <num> Prozent zur Masse bei bestimmt jedoch die Größe des Atoms
Der positive Kern und die negative Hülle sind durch elektrostatische Anziehung aneinander gebunden
In der elektrisch neutralen Grundform des Atoms ist die Anzahl der Elektronen in der Hülle gleich der Anzahl der Protonen im Kern
Diese Zahl legt den genauen Aufbau der Hülle und damit auch das chemische Verhalten des Atoms fest und wird deshalb als chemische Ordnungszahl
bezeichnet
Alle Atome desselben Elements haben die gleiche chemische Ordnungszahl
Sind zusätzliche Elektronen vorhanden oder fehlen welche ist das Atom negativ bzw positiv geladen und wird als Ion bezeichnet
Die Vorstellung vom atomaren Aufbau der Materie existierte bereits in der Antike war jedoch bis in die Neuzeit umstritten
Der endgültige Nachweis konnte erst Anfang des <num> Jahrhunderts erbracht werden und gilt als eine der bedeutendsten Entdeckungen in Physik und Chemie
Einzelne Atome sind selbst mit den stärksten Lichtmikroskopen nicht zu erkennen
Eine direkte Beobachtung einzelner Atome ist erst seit Mitte des <num> Jahrhunderts mit Feldionenmikroskopen möglich seit einigen Jahren auch mit Rastertunnelmikroskopen und hochauflösenden Elektronenmikroskopen
Die Atomphysik die neben dem Aufbau der Atome auch die Vorgänge in ihrem Inneren und ihre Wechselwirkungen mit anderen Atomen erforscht hat entscheidend zur Entwicklung der modernen Physik und insbesondere der Quantenmechanik beigetragen
Erforschungsgeschichte
Die Vorstellung vom atomaren Aufbau der Materie existierte bereits in der Antike
Aufgrund ihrer extrem geringen Größe sind einzelne Atome selbst mit den stärksten Lichtmikroskopen nicht zu erkennen noch Anfang des <num> Jahrhunderts war ihre Existenz umstritten
Der endgültige Nachweis gilt als eine der bedeutendsten Entdeckungen in Physik und Chemie
Einen entscheidenden Beitrag lieferte Albert Einstein <num> indem er die bereits seit langem bekannte im Mikroskop direkt sichtbare Brownsche Bewegung kleiner Körnchen durch zufällige Stöße von Atomen oder Molekülen in deren Umgebung erklärte
Erst seit wenigen Jahrzehnten erlauben Feldionenmikroskope und Rastertunnelmikroskope seit einigen Jahren zudem auch Elektronenmikroskope einzelne Atome direkt zu beobachten
Philosophische Überlegungen
Das Konzept des Atomismus nämlich dass Materie aus Grundeinheiten aufgebaut ist - kleinsten Teilchen die nicht immer weiter in kleinere Stücke zerteilt werden können - existiert seit Jahrtausenden genauso wie das Gegenkonzept Materie sei ein beliebig teilbares Kontinuum
Doch diese Ideen beruhten zunächst ausschließlich auf philosophischen Überlegungen und nicht auf empirischer experimenteller Untersuchung
Dabei wurden den Atomen verschiedene Eigenschaften zugeschrieben und zwar je nach Zeitalter Kultur und philosophischer Schule sehr unterschiedliche
Eine frühe Erwähnung des Atomkonzepts in der Philosophie ist aus Indien bekannt
Die Nyaya- und Vaisheshika-Schulen entwickelten ausgearbeitete Theorien wie sich Atome zu komplexeren Gebilden zusammenschlössen erst in Paaren dann je drei Paare
Experimentell arbeitende Naturwissenschaftler machten sich Ende des <num> Jahrhunderts die Hypothese vom Atom zu eigen weil diese Hypothese im Rahmen eines Teilchenmodells der Materie eine elegante Erklärung für neue Entdeckungen in der Chemie bot Doch wurde gleichzeitig die gegenteilige Vorstellung Materie sei ein Kontinuum von Philosophen und auch unter Naturwissenschaftlern noch bis ins <num> Jahrhundert hinein aufrechterhalten
In der griechischen Philosophie ist die Atomvorstellung erstmals im <num> Jahrhundert v Chr
bei Leukipp überliefert
Sein Schüler Demokrit systematisierte sie und führte den Begriff átomos ein was etwa das Unzerschneidbare bedeutet also ein nicht weiter zerteilbares Objekt
Diese Bezeichnung wurde Ende des <num> Jahrhunderts für die damals hypothetischen kleinsten Einheiten der chemischen Elemente der beginnenden modernen Chemie übernommen denn mit chemischen Methoden lassen sich Atome in der Tat nicht zerschneiden
Naturwissenschaftliche Erforschung
Im Rahmen der wissenschaftlichen Erforschung konnte die Existenz von Atomen bestätigt werden
Es wurden viele verschiedene Atommodelle entwickelt um ihren Aufbau zu beschreiben
Insbesondere das Wasserstoffatom als das einfachste aller Atome war dabei wichtig
Einige der Modelle werden heute nicht mehr verwendet und sind nur von wissenschaftsgeschichtlichem Interesse
Andere gelten je nach Anwendungsbereich als Näherung noch heute
In der Regel wird das einfachste Modell genommen welches im gegebenen Zusammenhang noch ausreicht um die auftretenden Fragen zu klären
Bestätigung der Atomhypothese
DateiA New System of Chemical Philosophy fpjpg
Robert Boyle vertrat <num> in seinem Werk
The Sceptical Chymist
die Meinung die Materie sei aus diversen Kombinationen verschiedener corpuscules aufgebaut und nicht aus den vier Elementen der Alchemie Wasser Erde Feuer Luft Damit bereitete er die Überwindung der Alchemie durch den Element- und Atombegriff der modernen Chemie vor
Daniel Bernoulli zeigte <num> dass der gleichmäßige Druck von Gasen auf die Behälterwände und insbesondere das Gesetz von Boyle und Mariotte sich durch zahllose Stöße kleinster Teilchen erklären lässt
Damit wurde seine Forschung zum Vorläufer der kinetischen Gastheorie und statistischen Mechanik
Ab Ende des <num> Jahrhunderts wurde die Vorstellung von Atomen genutzt um die wohlbestimmten Winkel an den Kanten und Ecken der Edelsteine auf die verschiedenen möglichen Schichtungen von harten Kugeln zurückzuführen
Nachdem Antoine Lavoisier <num> den heutigen Begriff des chemischen Elements geprägt und die ersten Elemente richtig identifiziert hatte benutzte <num> John Dalton das Atomkonzept um zu erklären wieso Elemente immer in Mengenverhältnissen kleiner ganzer Zahlen miteinander reagieren Gesetz der multiplen Proportionen
Er nahm an dass jedes Element aus gleichartigen Atomen besteht die sich nach festen Regeln miteinander verbinden können und so Stoffe mit anderen Materialeigenschaften bilden
Außerdem ging er davon aus dass alle Atome eines Elements die gleiche Masse hätten und begründete den Begriff Atomgewicht
Die Beobachtungen zum chemischen und physikalischen Verhalten von Gasen konnte Amedeo Avogadro <num> dahingehend zusammenfassen dass zwei näherungsweise ideale Gase bei gleichen Werten von Volumen Druck und Temperatur des Gases immer aus gleich vielen identischen Teilchen Molekülen bestehen
Die Moleküle bestehen bei elementaren Gasen wie Wasserstoff Sauerstoff oder Stickstoff immer aus zwei Atomen des Elements Avogadrosches Gesetz
<num> konnte Johann Loschmidt die Größe der Luftmoleküle bestimmen indem er mit der von James C Maxwell aus der kinetischen Gastheorie gewonnenen Formel die von George Stokes gemessenen Werte für die innere Reibung in Luft auswertete Damit konnte er das Gewicht eines Luftmoleküls bestimmen
Außerdem erhielt er die nach ihm benannte Loschmidtsche Zahl als Anzahl der Luftmoleküle pro Kubikzentimeter
Infolge der Arbeiten von Avogadro und Stanislao Cannizzaro wurde angenommen dass Atome nicht als einzelne Teilchen auftreten sondern nur als Bestandteile von Molekülen aus mindestens zwei Atomen
Doch <num> gelang August Kundt und Emil Warburg der erste Nachweis eines einatomigen Gases
Sie bestimmten den Adiabatenexponenten von Quecksilber-Dampf bei hoher Temperatur und erhielten einen Wert wie er nach der kinetischen Gastheorie nur für Teilchen in Gestalt echter Massepunkte auftreten kann
Ab <num> kamen entsprechende Beobachtungen an den neu entdeckten Edelgasen hinzu
Nach Erscheinen seiner Dissertation über die Bestimmung von Moleküldimensionen schlug Albert Einstein im selben Jahr <num> ein Experiment vor um die Hypothese von der Existenz der Atome anhand der Zitterbewegung kleiner Partikel in Wasser quantitativ zu prüfen
Nach seiner Theorie müssten die Partikel aufgrund der Unregelmäßigkeit der Stöße durch die Wassermoleküle kleine aber immerhin unter dem Mikroskop sichtbare Bewegungen ausführen
Es war Einstein dabei zunächst nicht bekannt dass er damit die seit <num> bekannte Brownsche Bewegung von Pollen quantitativ erklärt hatte für deren Ursache schon <num> Christian Wiener erstmals Molekularstöße angenommen hatte Der französische Physiker Jean Perrin bestimmte auf der Grundlage von Einsteins Theorie die Masse und Größe von Molekülen experimentell und fand ähnliche Ergebnisse wie Loschmidt Diese Arbeiten trugen entscheidend zur allgemeinen Anerkennung der bis dahin so genannten Atomhypothese bei
Teilbarkeit und Aufbau der Atome
Joseph John Thomson entdeckte <num> dass die Kathodenstrahlen aus Teilchen bestimmter Ladung und Masse bestehen deren Masse kleiner als ein Tausendstel der Atommasse ist
Diese Teilchen wurden als Elektronen bezeichnet und erwiesen sich als ein Bestandteil aller Materie was dem Konzept des Atoms als unzerteilbarer Einheit widersprach Thomson glaubte dass die Elektronen dem Atom seine Masse verliehen und dass sie im Atom in einem masselosen positiv geladenen Medium verteilt seien wie Rosinen in einem Kuchen Thomsonsches Atommodell
Die kurz zuvor entdeckte Radioaktivität wurde <num> von Ernest Rutherford und Frederick Soddy mit Umwandlungen verschiedener Atomsorten ineinander in Verbindung gebracht
Sie konnten <num> nachweisen dass α-Teilchen die bei Alphastrahlung ausgesandt werden Helium-Atome bilden
Zusammen mit seiner Forschergruppe beschoss Ernest Rutherford <num> eine Goldfolie mit α-Teilchen
Er stellte fest dass die meisten der Teilchen die Folie fast ungehindert durchdrangen einige wenige aber um sehr viel größere Winkel abgelenkt wurden als nach Thomsons Modell möglich
Rutherford schloss daraus dass fast die ganze Masse des Atoms in einem sehr viel kleineren geladenen Atomkern in der Mitte des Atoms konzentriert sei Rutherfordsches Atommodell
Die stark abgelenkten α-Teilchen waren diejenigen die einem Kern zufällig näher als etwa ein Hundertstel des Atomradius gekommen waren Die Ladungszahl des Atomkerns entpuppte sich als die chemische Ordnungszahl des betreffenden Elements und α-Teilchen erwiesen sich als die Atomkerne des Heliums
DateiMass Spectrometer Schematic DEsvg
Der Chemiker Frederick Soddy stellte <num> fest dass manche der natürlichen radioaktiven Elemente aus Atomen mit unterschiedlichen Massen und unterschiedlicher Radioaktivität bestehen mussten Der Begriff Isotop für physikalisch verschiedene Atome desselben chemischen Elements wurde <num> von Margaret Todd vorgeschlagen Da die Isotope desselben Elements an ihrem chemischen Verhalten nicht zu unterscheiden waren entwickelte der Physiker JJ Thomson ein erstes Massenspektrometer zu ihrer physikalischen Trennung
Damit konnte er <num> am Beispiel von Neon nachweisen dass es auch stabile Elemente mit mehreren Isotopen gibt
<num> fand Francis William Aston mit einem Massenspektrometer von erheblich größerer Genauigkeit heraus dass fast alle Elemente Gemische aus mehreren Isotopen sind wobei die Massen der einzelnen Isotope immer nahezu ganzzahlige Vielfache der Masse des Wasserstoffatoms sind Rutherford wies <num> in der ersten beobachteten Kernreaktion nach dass durch Beschuss mit α-Teilchen aus den Kernen von Stickstoffatomen die Kerne von Wasserstoffatomen herausgeschossen werden können
Diesen gab er den Namen Proton und entwickelte ein Atommodell in dem die Atome nur aus Protonen und Elektronen bestehen wobei die Protonen und ein Teil der Elektronen den kleinen schweren Atomkern bilden die übrigen Elektronen die große leichte Atomhülle
Die Vorstellung von Elektronen im Atomkern stellte sich jedoch als falsch heraus und wurde fallengelassen nachdem <num> von James Chadwick das Neutron als ein neutraler Kernbaustein mit etwa gleicher Masse wie das Proton nachgewiesen wurde Damit entstand das heutige Atommodell Der Atomkern ist zusammengesetzt aus so vielen Protonen wie die Ordnungszahl angibt und zusätzlich so vielen Neutronen dass die betreffende Isotopenmasse erreicht wird
Quantenmechanische Atommodelle
DateiBohr atom modelsvg
<num> konnte Niels Bohr aufbauend auf Rutherfords Atommodell aus Kern und Hülle erstmals erklären wie es in den optischen Spektren reiner Elemente zu den Spektrallinien kommt die für das jeweilige Element absolut charakteristisch sind Spektralanalyse nach Robert Wilhelm Bunsen und Gustav Robert Kirchhoff <num>
Bohr nahm an dass die Elektronen sich nur auf bestimmten quantisierten Umlaufbahnen Schalen aufhalten und von einer zur anderen springen sich jedoch nicht dazwischen aufhalten können Beim Quantensprung von einer äußeren zu einer weiter innen liegenden Bahn muss das Elektron eine bestimmte Menge an Energie abgeben die als Lichtquant bestimmter Wellenlänge erscheint
Im Franck-Hertz-Versuch konnte die quantisierte Energieaufnahme und -abgabe an Quecksilberatomen experimentell bestätigt werden
Das Bohrsche Atommodell ergab zwar nur für Systeme mit lediglich einem Elektron Wasserstoff und ionisiertes Helium quantitativ richtige Resultate
Jedoch bildete es im Laufe des folgenden Jahrzehnts das Fundament für eine Reihe von Verfeinerungen die zu einem qualitativen Verständnis des Aufbaus der Elektronenhüllen aller Elemente führten
Damit wurde das Bohrsche Atommodell zur Grundlage des populären Bildes vom Atom als einem kleinen Planetensystem
<num> versuchte Gilbert Newton Lewis im Rahmen des Bohrschen Atommodells die chemische Bindung durch Wechselwirkung der Elektronen eines Atoms mit einem anderen Atom zu erklären Walther Kossel ging <num> erstmals von abgeschlossenen Elektronenschalen bei den Edelgasen aus um zu erklären dass die chemischen Eigenschaften der Elemente grob periodisch mit der Ordnungszahl variieren wobei sich benachbarte Elemente durch ein oder zwei zusätzliche oder fehlende Elektronen unterscheiden Dies wurde bis <num> von Niels Bohr zum Aufbauprinzip weiterentwickelt wonach mit zunehmender Kernladungszahl jedes weitere Elektron in die jeweils energetisch niedrigste Elektronenschale der Atomhülle die noch Plätze frei hat aufgenommen wird ohne dass die schon vorhandenen Elektronen sich wesentlich umordnen
DateiAOs-<num>D-dotspng Aufbauend auf dem von Louis de Broglie <num> postulierten Welle-Teilchen-Dualismus entwickelte Erwin Schrödinger <num> die Wellenmechanik
Sie beschreibt die Elektronen nicht als Massenpunkte auf bestimmten Bahnen sondern als dreidimensionale
Materiewellen
Als Folge dieser Beschreibung ist es unter anderem unzulässig einem Elektron gleichzeitig genaue Werte für Ort und Impuls zuzuschreiben
Dieser Sachverhalt wurde <num> von Werner Heisenberg in der Unschärferelation formuliert
Demnach können statt der Bewegung auf bestimmten Bahnen nur Wahrscheinlichkeitsverteilungen für Wertebereiche von Ort und Impuls angegeben werden eine Vorstellung die nur schwer zu veranschaulichen ist
Den quantisierten Umlaufbahnen des Bohrschen Modells entsprechen hier stehende Materiewellen oder Atomorbitale Sie geben unter anderem an wie sich in der Nähe des Atomkerns die Aufenthaltswahrscheinlichkeit der Elektronen konzentriert und bestimmen damit die wirkliche Größe des Atoms
Die Beschreibung der Eigenschaften der Atome gelang mit diesem ersten vollständig quantenmechanischen Atommodell sehr viel besser als mit den Vorläufermodellen
Insbesondere ließen sich auch bei Atomen mit mehreren Elektronen die Spektrallinien und die Struktur der Atomhülle in räumlicher und energetischer Hinsicht darstellen einschließlich der genauen Möglichkeiten mit den Atomhüllen anderer Atome gebundene Zustände zu bilden also stabile Moleküle
Daher wurde das Bohrsche Atommodell zugunsten des quantenmechanischen Orbitalmodells des Atoms verworfen
Das Orbitalmodell ist bis heute Grundlage und Ausgangspunkt genauer quantenmechanischer Berechnungen fast aller Eigenschaften der Atome
Das gilt insbesondere für ihre Fähigkeit sich mit anderen Atomen zu einzelnen Molekülen oder zu ausgedehnten Festkörpern zu verbinden
Bei Atomen mit mehreren Elektronen muss dafür außer dem Pauli-Prinzip auch die elektrostatische Wechselwirkung jedes Elektrons mit allen anderen berücksichtigt werden
Diese hängt u a von der Form der besetzten Orbitale ab
Andererseits wirkt sich umgekehrt die Wechselwirkung auf die Form und Energie der Orbitale aus
Es ergibt sich das Problem die Orbitale in selbstkonsistenter Weise so zu bestimmen dass sich ein stabiles System ergibt
Die Hartree-Fock-Methode geht von Orbitalen einer bestimmten Form aus und variiert diese systematisch bis die Rechnung eine minimale Gesamtenergie ergibt
Wenn man die Orbitale nach der Dichtefunktionaltheorie bestimmen will geht man von einer ortsabhängigen Gesamtdichte der Elektronen aus und bildet daraus eine Schrödingergleichung zur Bestimmung der Orbitale der einzelnen Elektronen
Hier wird die anfänglich angenommene Gesamtdichte variiert bis sie mit der Gesamtdichte die aus den besetzten Orbitalen zu berechnen ist gut übereinstimmt
Das Orbitalmodell bei einem Atom mit mehr als einem Elektron ist physikalisch als eine Näherung zu bezeichnen nämlich als eine Ein-Teilchen-Näherung
Sie besteht darin dass jedem einzelnen Elektron ein bestimmtes Orbital zugeschrieben wird
Ein so gebildeter Zustand gehört zu der einfachsten Art von Mehrteilchenzuständen und wird hier als Konfiguration des Atoms bezeichnet
Genauere Modelle berücksichtigen dass nach den Regeln der Quantenmechanik die Hülle auch in einem Zustand sein kann der durch Superposition verschiedener Konfigurationen entsteht wo also mit verschiedenen Wahrscheinlichkeitsamplituden gleichzeitig verschiedene Elektronenkonfigurationen vorliegen eine sogenannte Konfigurationsmischung
Hiermit werden die genauesten Berechnungen von Energieniveaus und Wechselwirkungen der Atome möglich
Wegen des dazu nötigen mathematischen Aufwands werden jedoch wo es möglich ist auch weiterhin einfachere Atommodelle genutzt
Zu nennen ist hier das Thomas-Fermi-Modell in dem die Elektronenhülle pauschal wie ein im Potentialtopf gebundenes ideales Elektronengas das Fermigas behandelt wird dessen Dichte wiederum die Form des Potentialtopfs bestimmt
Erklärung grundlegender Atomeigenschaften
Die Elektronen der Atomhülle sind aufgrund ihrer negativen Ladung durch elektrostatische Anziehung an den positiven Atomkern gebunden
Anschaulich bilden sie eine Elektronenwolke ohne scharfen Rand
Ein neutrales Atom enthält genauso viele Elektronen in der Hülle wie Protonen im Kern
Die Hülle hat einen etwa zehn- bis hunderttausend Mal größeren Durchmesser als der Kern trägt jedoch weniger als <num> Prozent zur Atommasse bei
Sie ist für energiereiche freie Teilchen z B
Photonen der Röntgenstrahlung oder Elektronen und Alphateilchen der radioaktiven Strahlung mit Energien ab einigen hundert Elektronenvolt eV sehr durchlässig
Daher wird das Atom zuweilen als weitgehend leer beschrieben
Für geladene Teilchen geringer Energie im Bereich bis zu einigen zehn eV ist die Hülle aber praktisch undurchdringlich
In diesem Bereich liegen auch die kinetische Energie und die Bindungsenergie der Elektronen im äußeren Teil der Hülle
Daher erfahren zwei Atome immer eine starke Abstoßungskraft wenn sie sich so weit annähern dass sich ihre Hüllen merklich überschneiden würden
Der Bereich der kinetischen Energien ganzer Atome und Moleküle wie sie unter normalen Bedingungen auf der Erde vorkommen liegt noch deutlich darunter
Z B
beträgt die thermische Energie
Boltzmannkonstante
absolute Temperatur die für die Größenordnung dieses Energiebereichs typisch ist bei Raumtemperatur nur ungefähr <num> eV
Unter diesen Bedingungen ist die Atomhülle daher erstens stabil weil ihr keine Elektronen entrissen werden und zweitens undurchdringlich weil sie sich nicht merklich mit den Hüllen anderer Atome überschneidet
Damit wird das Atom zum universellen Baustein der alltäglichen makroskopischen Materie
Seine wenn auch nicht ganz scharf definierte Größe verdankt es der gegenseitigen Undurchdringlichkeit der Hüllen
Wenn sich die Hüllen zweier Atome aber nur geringfügig mit ihren äußeren Randbereichen überschneiden kann zwischen ihnen eine anziehende Kraft entstehen
Sie ist die Ursache für die Entstehung von stabilen Molekülen also den kleinsten Teilchen einer chemischen Verbindung
Bedingung ist dass insgesamt ein Gewinn an Bindungsenergie damit einhergeht dass ein oder zwei Elektronen von einer Hülle ganz oder mit gewisser Wahrscheinlichkeit zu der anderen Hülle überwechseln oder an beiden Hüllen beteiligt sind
Das ist nur bei genau passendem Aufbau beider Hüllen gegeben
Daher treten chemische Bindungen nur bei entsprechend geeigneten Kombinationen von Atomen auf
Bei größeren Abständen etwa bei einigen Atomdurchmessern ziehen sich hingegen Atome aller Arten gegenseitig schwach an unabhängig von der Möglichkeit eine chemische Bindung einzugehen
Diese Van-der-Waals-Kräfte bewirken dass jedes Gas bei genügend niedriger Temperatur zu einer Flüssigkeit oder einem Feststoff kondensiert
Sie sind also für den Wechsel der Aggregatzustände verantwortlich und wirken zwischen den neutralen Atomen bzw Molekülen sind aber auch elektrischen Ursprungs
Sie werden dadurch erklärt dass sich zwei Atome durch leichte räumliche Verschiebung ihrer Elektronenwolken gegenseitig elektrische Dipolmomente induzieren die einander elektrostatisch anziehen
Weitere Entdeckungen
Der Chemiker Otto Hahn ein Schüler Rutherfords versuchte im Jahr <num> durch Einfang von Neutronen an Urankernen Atome mit größerer Masse Transurane herzustellen wie das bei leichteren Elementen seit Jahren gelungen war
Fritz Straßmann wies jedoch überraschenderweise nach dass dabei das viel leichtere Barium entstanden war
Die Physiker Lise Meitner und Otto Frisch konnten den Vorgang als Kernspaltung identifizieren indem sie mittels einer Ionisationskammer mehrere radioaktive Spaltprodukte nachwiesen
Ab den <num>er Jahren konnten Atome durch die Entwicklung verbesserter Teilchenbeschleuniger und Teilchendetektoren beim Beschuss mit Teilchen sehr hoher Energie untersucht werden Ende der <num>er Jahre zeigte sich in der tiefinelastischen Streuung von Elektronen an Atomkernen dass auch Neutronen und Protonen keine unteilbaren Einheiten sind sondern aus Quarks zusammengesetzt sind
<num> entwickelte Erwin Müller das Feldionenmikroskop und konnte damit von einer Nadelspitze erstmals ein Abbild erzeugen das auf direkte Weise so stark vergrößert war dass einzelne Atome darin sichtbar wurden wenn auch nur als verschwommene Flecken
<num> entwickelte Wolfgang Paul die magnetische Ionenfalle Paulfalle in der einzelne Ionen gespeichert und mit immer höherer Genauigkeit untersucht werden konnten
<num> entwickelte eine Arbeitsgruppe um Steven Chu die Laserkühlung ein Verfahren die Temperatur einer Ansammlung von Atomen mittels Laserstrahlung stark zu verringern
Im selben Jahr gelang es einer Gruppe um William D Phillips neutrale Natriumatome in einer magneto-optischen Falle einzuschließen
Durch Kombination dieser Verfahren mit einer Methode die den Dopplereffekt nutzt gelang es einer Arbeitsgruppe um Claude Cohen-Tannoudji geringe Mengen von Atomen auf Temperaturen von einigen Mikrokelvin zu kühlen
Mit diesem Verfahren können Atome mit höchster Genauigkeit untersucht werden außerdem ermöglichte es auch die experimentelle Realisierung der Bose-Einstein-Kondensation
Anfang der <num>er Jahre wurde von Gerd Binnig und Heinrich Rohrer das Rastertunnelmikroskop entwickelt in dem eine Nadelspitze eine Oberfläche mittels des Tunneleffekts so fein abtastet dass einzelne Atome sichtbar werden
Damit wurde es auch möglich Atome einzeln an bestimmte Plätze zu setzen
In den <num>er Jahren konnten Serge Haroche und David Wineland in Experimenten die Wechselwirkung eines einzelnen Atoms mit einem einzelnen Photon erfolgreich untersuchen
In den <num>er Jahren wurde die Handhabbarkeit einzelner Atome unter anderem genutzt um einen Transistor aus nur einem Metallatom mit organischen Liganden herzustellen
Viele dieser Entdeckungen wurden mit dem Nobelpreis Physik oder Chemie ausgezeichnet
Klassifizierung
DateiPeriodensystem Z A Name Deutschsvg DateiIsotopentabelle Segresvg
Elemente Isotope Nuklide
Die Unterscheidung und Bezeichnung verschiedener Atomsorten geht zunächst vom Aufbau des Atomkerns aus während der Zustand der Hülle gegebenenfalls durch zusätzliche Symbole angegeben wird
Kennzahlen sind die Protonenzahl Ordnungszahl Kernladungszahl Z die Neutronenzahl N des Kerns und die daraus gebildete Massenzahl AZN
Je nach ihrer Protonenzahl gehören die Atome zu einem der <num> bekannten chemischen Elemente von Wasserstoff mit Z<num> bis Oganesson mit Z<num>
Davon sind <num> in natürlichen Vorkommen entdeckt worden <num> nur nach künstlicher Herstellung durch Kernreaktionen
Die Ordnung der Elemente wird im Periodensystem - wichtig für die Chemie - graphisch veranschaulicht
Darin werden die Elemente mit aufsteigender Ordnungszahl in Form einer Tabelle angeordnet
Jede Zeile wird als Periode des Periodensystems bezeichnet und endet wenn das jeweilige Orbital mit Elektronen voll besetzt ist Edelgas
In den nächsten Zeilen wiederholt sich aufgrund der schrittweisen Elektronenbesetzung der nächsten Orbitale der chemische Charakter der Elemente
So stehen Elemente mit ähnlichen chemischen Eigenschaften in einer Spalte untereinander sie bilden eine Gruppe des Periodensystems
Atome eines Elements die sich in der Neutronenzahl unterscheiden gehören zu verschiedenen Isotopen des Elements
Insgesamt bestehen die <num> Elemente aus etwa <num> Isotopen wovon <num> künstlich erzeugt wurden
Isotope werden - bis auf die Ausnahmen der Wasserstoffisotope Deuterium und Tritium - nach dem chemischen Element und der Massenzahl bezeichnet
Das Symbol für ein bestimmtes Isotop des Elements X hat die Form
oder X-A Beispiele
Pb-<num>
Die Angabe der Protonenzahl Z ist redundant da sich Z schon aus der Ordnungszahl des Elements ergibt
Nuklid ist die ganz allgemeine Bezeichnung für Atomarten unabhängig davon ob sie zum gleichen Element gehören oder nicht
Die Nuklidkarte oder Isotopenkarte - wichtig für die Kernphysik und ihre Anwendungen - ist eine Tabelle in der jede Atomart einen eigenen Platz erhält
Dazu wird auf einer Achse die Anzahl der Protonen auf der anderen die der Neutronen aufgetragen
Häufig wird die Stabilität und bei instabilen Nukliden auch die Art der Umwandlung oder die Größenordnung der Halbwertszeit durch bestimmte Farben dargestellt
Stabile und instabile radioaktive Atome
Der Atomkern eines Nuklids
kann im energetischen Grundzustand und in verschiedenen Anregungszuständen vorliegen
Wenn darunter relativ langlebige sogenannte metastabile Zustände sind werden diese als Isomere bezeichnet und als eigene Nuklide gezählt Symbol
o ä Nach dieser Definition sind mit dem Stand von <num> insgesamt etwa <num> Nuklide bekannt
In der Kernphysik werden Nuklide mit unterschiedlichen Protonenzahlen aber gleicher Massenzahl
als Isobare bezeichnet
Seltener werden unter dem Namen Isotone Nuklide mit verschiedenen Protonenzahlen aber gleicher Neutronenzahl zusammengefasst
Nur etwa <num> Isotope von <num> Elementen haben einen stabilen Kern
Alle anderen Atome sind instabil und wandeln sich über kurz oder lang in Atome eines stabilen Isotops um
Da sie dabei im Allgemeinen ionisierende Strahlung aussenden heißen sie auch Radioisotope oder Radionuklide
Auf der Erde wurden in den natürlichen Vorkommen neben allen <num> stabilen Isotopen <num> Radioisotope gefunden die sich auf <num> radioaktive Elemente verteilen und die natürliche Radioaktivität verursachen Viele weitere kurzlebige Isotope existieren im Inneren von Sternen insbesondere während der Supernova-Phase
Seltene und theoretische Formen
Als Rydberg-Atom wird ein Atom bezeichnet in dem ein Elektron in einem so hohen Energiezustand angeregt ist dass es den Atomkern teilweise auch den gesamten Atomrumpf bestehend aus dem Atomkern und den restlichen Elektronen in weitem Abstand umkreist und sein Verhalten damit dem eines klassischen Teilchens ähnelt
Rydberg-Atome können über <num>-mal größer sein als nicht angeregte Atome
Da sie extrem empfindlich auf äußere Felder reagieren kann man mit ihnen z B
die Wechselwirkung mit einem einzelnen Photon im Detail untersuchen
Sind zwei oder mehr Elektronen in solchen Zuständen angeregt spricht man von planetarischen Atomen
Im teils übertragenen Sinn werden als exotische Atome auch solche Systeme bezeichnet die in physikalischer Hinsicht gewisse Ähnlichkeiten zu den gewöhnlichen Atomen aufweisen
In ihnen kann z B
eines der Protonen Neutronen oder Elektronen durch ein anderes Teilchen derselben Ladung ersetzt worden sein
Wird etwa ein Elektron durch ein schwereres Myon ersetzt bildet sich ein myonisches Atom
Als Positronium wird ein exotisches Atom bezeichnet in dem ein Elektron statt an ein Proton an ein Positron das ist das positiv geladene Antiteilchen des Elektrons gebunden ist
Auch Atome die gänzlich aus Antiteilchen zur normalen Materie aufgebaut sind sind möglich
So wurden erstmals <num> am Genfer CERN Antiwasserstoffatome künstlich hergestellt und nachgewiesen An solchen exotischen Atomen lassen sich unter anderem fundamentale physikalische Theorien überprüfen
Des Weiteren wird der Name Atom manchmal auch für Zwei-Teilchen-Systeme verwendet die nicht durch elektromagnetische Wechselwirkung zusammengehalten werden sondern durch die starke Wechselwirkung
Bei einem solchen Quarkonium handelt es sich um ein kurzlebiges Elementarteilchen vom Typ Meson das aus einem Quark und seinem Antiteilchen aufgebaut ist
Ein Quarkonium-Atom lässt sich in seinen verschiedenen metastabilen Zuständen so durch Quantenzahlen klassifizieren wie das Wasserstoffatom
Entstehung
Etwa eine Sekunde nach dem Urknall kamen die ständigen Umwandlungen zwischen den Elementarteilchen zur Ruhe übrig blieben Elektronen Protonen und Neutronen
In den darauf folgenden drei Minuten verbanden sich in der primordialen Nukleosynthese die vorhandenen Neutronen mit Protonen zu den einfachsten Kernen Deuterium Helium in geringerem Umfang auch Lithium und möglicherweise in noch kleineren Mengen Beryllium und Bor
Die übrigen Protonen <num> Prozent blieben erhalten Die ersten neutralen Atome mit dauerhaft gebundenen Elektronen wurden erst <num> Jahre nach dem Urknall in der Rekombinationsphase gebildet als das Universum durch Expansion so weit abgekühlt war dass die Atome nicht sogleich wieder ionisiert wurden
Die Kerne aller schwereren Atome wurden und werden durch verschiedene Prozesse der Kernfusion erzeugt
Am wichtigsten ist die stellare Nukleosynthese durch die in Sternen zunächst Helium anschließend auch die schwereren Elemente bis zum Eisen gebildet werden
Elemente mit höheren Kernladungszahlen als Eisen entstehen in explosionsartigen Vorgängen wie im r-Prozess in Supernovae und im s-Prozess in AGB-Sternen die kurz vor dem Ende ihrer Lebensdauer sind
Kleine Mengen verschiedener Elemente und Isotope werden auch dadurch gebildet dass schwere Kerne wieder geteilt werden
Das geschieht durch radioaktive Zerfälle siehe Zerfallsreihe die u a für einen Teil des Vorkommens von Helium und Blei verantwortlich sind und Spallationen die für die Entstehung von Lithium Beryllium und Bor wichtig sind
Vorkommen und Verteilung
DateiElement-haeufigkeitsvg
Im beobachtbaren Universum liegen die Atome mit einer mittleren Dichte von <num> Atomem vor
Nach dem Urknallmodell Lambda-CDM-Modell bilden sie etwa <num> Prozent der gesamten Energiedichte
Der Rest dessen Natur noch weitgehend unklar ist setzt sich aus etwa <num> Prozent dunkler Materie und <num> Prozent dunkler Energie zusammen sowie kleinen Beiträgen von Neutrinos und elektromagnetischer Strahlung Im Inneren einer Galaxie wie etwa der Milchstraße ist im interstellaren Medium ISM die Dichte der Atome wesentlich höher und liegt zwischen <num> und <num> Atomem<num> Die Sonne befindet sich in der weitgehend staubfreien lokalen Blase daher ist die Dichte in der Umgebung des Sonnensystems nur etwa <num> Atomem<num> In festen Himmelskörpern wie der Erde beträgt die Atomdichte etwa <num> Atomem<num>
In der Verteilung der Elemente dominiert im Universum Wasserstoff mit rund drei Viertel der Masse danach folgt Helium mit etwa einem Viertel
Alle schwereren Elemente sind viel seltener und machen nur einen kleinen Teil der im Universum vorhandenen Atome aus
Ihre Häufigkeiten werden von den verschiedenen Mechanismen der Nukleosynthese bestimmt
Im Sonnensystem sind Wasserstoff und Helium vorwiegend in der Sonne und den Gasplaneten enthalten
Dagegen überwiegen auf der Erde die schweren Elemente
Die häufigsten Elemente sind hier Sauerstoff Eisen Silicium und Magnesium
Der Erdkern besteht vorwiegend aus Eisen während in der Erdkruste Sauerstoff und Silicium vorherrschen
Bestandteile des Atoms
Die beiden Hauptbestandteile eines Atoms sind der Atomkern und die Atomhülle
Die Hülle besteht aus Elektronen
Sie trägt mit weniger als <num> Prozent zur Masse des Atoms bei bestimmt aber dessen Größe und dessen Verhalten gegenüber anderen Atomen wenn sie einander nahe kommen
Der Kern besteht aus Protonen und Neutronen ist im Durchmesser zehn- bis hunderttausendmal kleiner als die Hülle enthält aber mehr als <num> Prozent der Masse des Atoms
Atomkern
Aufbau
DateiBinding energy curve - common isotopes DEsvg
Die in einem Atom vorhandenen Protonen und Neutronen zusammen auch als Nukleonen bezeichnet sind aneinander gebundenen und bilden den Atomkern
Die Nukleonen zählen zu den Hadronen
Das Proton ist positiv geladen das Neutron ist elektrisch neutral
Proton und Neutron haben einen Durchmesser von etwa <num> fm Femtometer und sind selber keine Elementarteilchen sondern nach dem Standardmodell der Elementarteilchenphysik aus den punktförmigen Quarks aufgebaut
Jeweils drei Quarks binden sich durch die starke Wechselwirkung die durch Gluonen vermittelt wird zu einem Nukleon
Die starke Wechselwirkung ist darüber hinaus für den Zusammenhalt der Nukleonen im Atomkern verantwortlich insbesondere ist die Anziehung bis zu etwa <num> fm Abstand deutlich stärker als die gegenseitige elektrische Abstoßung der Protonen Unterhalb von etwa <num> fm wird die starke Wechselwirkung der Hadronen jedoch stark abstoßend
Anschaulich gesprochen verhalten sich die Nukleonen im Kern also etwa wie harte Kugeln die aneinander haften
Daher steigt das Volumen des Kerns proportional zur Nukleonenzahl Massenzahl
Sein Radius beträgt etwa
fm
Der leichteste Atomkern besteht aus nur einem Proton
Mehrere Protonen stoßen sich zwar gemäß der Elektrostatik ab können zusammen mit einer geeigneten Anzahl von Neutronen aber ein stabiles System bilden
Doch schon bei kleinen Abweichungen von dem energetisch günstigsten Zahlenverhältnis ist der Kern instabil und wandelt sich spontan um indem aus einem Neutron ein Proton wird oder umgekehrt und die frei werdende Energie und Ladung als Betastrahlung abgegeben wird
Kerne mit bis zu etwa <num> Protonen sind nur bei annähernd gleich großer Neutronenzahl stabil
Darüber steigt in den stabilen Atomkernen das Verhältnis von Neutronen zu Protonen von <num> bis auf etwa <num><num> weil bei größeren Protonenzahlen wegen ihrer elektrostatischen Abstoßung die Anzahl der Neutronen schneller anwachsen muss als die der Protonen Details siehe Tröpfchenmodell
Die Bindungsenergie liegt in stabilen Kernen abgesehen von den leichtesten oberhalb von <num> MeV pro Nukleon siehe Abbildung und übertrifft damit die Bindungsenergie der äußeren Elektronen der Atomhülle oder die chemische Bindungsenergie in stabilen Molekülen um das ca <num>-fache
Kerne mit bestimmten Nukleonenzahlen die als Magische Zahl bezeichnet werden beispielsweise Helium-<num> Sauerstoff-<num> oder Blei-<num> sind besonders stabil was mit dem Schalenmodell des Atomkerns erklärt werden kann
Oberhalb einer Zahl von <num> Protonen also jenseits von Blei sind alle Kerne instabil
Sie wandeln sich durch Ausstoßen eines Kerns He-<num> in leichtere Kerne um Alphastrahlung
Dies wiederholt sich zusammen mit Betastrahlung so lange bis ein stabiler Kern erreicht ist mehrere Zerfallsstufen bilden eine Zerfallsreihe
Auch zu den Protonenzahlen <num> Technetium und <num> Promethium existiert kein stabiler Kern
Daher kann es insgesamt nur <num> verschiedene stabile chemische Elemente geben alle weiteren sind radioaktiv
Sie kommen auf der Erde nur dann natürlich vor wenn sie selber oder eine ihrer Muttersubstanzen eine genügend lange Halbwertzeit haben
Masse
Da der Großteil der Atommasse von den Neutronen und Protonen stammt und diese etwa gleich schwer sind wird die Gesamtzahl dieser Teilchen in einem Atom als Massenzahl bezeichnet
Die genaue Masse eines Atoms wird oft in der atomaren Masseneinheit u angegeben ihr Zahlenwert ist dann etwa gleich der Massenzahl
Kleinere Abweichungen entstehen durch den Massendefekt der Atomkerne
Die atomare Masseneinheit ergibt sich aus der Definition der SI-Einheit des Mols in der Art und Weise dass ein Atom des Kohlenstoffisotops <num>C im Grundzustand inklusive seiner Hüllenelektronen eine Masse von exakt <num> u besitzt
Damit beträgt <num> u gleich <num>
<num>-<num> kg Ein Atom des leichtesten Wasserstoffisotops hat eine Masse von <num> u
Das schwerste stabile Nuklid ist das Bleiisotop <num>Pb mit einer Masse von <num> u
Da makroskopische Stoffmengen so viele Atome enthalten dass die Angabe ihrer Anzahl als natürliche Zahl unhandlich wäre erhielt die Stoffmenge eine eigene Einheit das Mol
Ein Mol sind etwa <num>nbspnbsp<num><sup><num><sup> Atome oder auch Moleküle oder andere Teilchen die betrachtete Teilchenart muss immer mitgenannt werden
Die Masse von <num> Mol Atomen der Atommasse X u ist daher exakt X g Daher ist es in der Chemie üblich Atommassen statt in u auch indirekt in gmol anzugeben
Bildung und Zerfall
In welcher Art ein instabiler Atomkern zerfällt ist für das jeweilige Radionuklid typisch
Bei manchen Nukliden können die untereinander völlig gleichen Kerne auch auf verschiedene Arten zerfallen so dass mehrere Zerfallskanäle mit bestimmten Anteilen beteiligt sind
Die wichtigsten radioaktiven Zerfälle sind
Alpha-Zerfall bei dem sich aus zwei Protonen und zwei Neutronen des Kerns durch die starke Wechselwirkung ein Helium-Atomkern bildet der ausgestoßen wird
Beta-Zerfall bei dem mittels der schwachen Wechselwirkung ein Neutron des Kerns in ein Proton oder umgekehrt umgewandelt wird und ein Elektron und ein Antineutrino beziehungsweise ein Positron und ein Neutrino ausgesendet werden
Gamma-Zerfall bei dem ein angeregter Kern durch elektromagnetische Wechselwirkung Gammastrahlung erzeugt und in ein niedrigeres Energieniveau gelangt bei gleichbleibender Protonen- und Neutronenzahl
DateiNuclear fusionsvg Die Energien der Strahlungen sind für das jeweilige Nuklid charakteristisch ebenso wie die Halbwertszeit die angibt wie lange es dauert bis die Hälfte einer Probe des Nuklids zerfallen ist
Durch Anlagerung eines Neutrons kann sich ein Kern in das nächstschwerere Isotop desselben Elements verwandeln
Durch den Beschuss mit Neutronen oder anderen Atomkernen kann ein großer Atomkern in mehrere kleinere Kerne gespalten werden
Einige schwere Nuklide können sich auch ohne äußere Einwirkung spontan spalten
Größere Atomkerne können aus kleineren Kernen gebildet werden
Dieser Vorgang wird Kernfusion genannt
Für eine Fusion müssen sich Atomkerne sehr nahe kommen
Diesem Annähern steht die elektrostatische Abstoßung beider Kerne der sogenannte Coulombwall entgegen
Aus diesem Grund ist eine Kernfusion außer in bestimmten Experimenten nur unter sehr hohen Temperaturen von mehreren Millionen Grad und hohen Drücken wie sie im Inneren von Sternen herrschen möglich
Die Kernfusion ist bei Nukliden bis zum Nickel-<num> eine exotherme Reaktion so dass sie im Großen selbsterhaltend ablaufen kann
Sie ist die Energiequelle der Sterne
Bei Atomkernen jenseits des Nickels nimmt die Bindungsenergie pro Nukleon ab die Fusion schwererer Atomkerne ist daher endotherm und damit kein selbsterhaltender Prozess
Die Kernfusion in Sternen kommt daher zum Erliegen wenn die leichten Atomkerne aufgebraucht sind
Atomhülle
Aufbau und Bindungsenergie
Die Atomhülle besteht aus Elektronen die aufgrund ihrer negativen Ladung an den positiven Atomkern gebunden sind
Sie wird oft auch als Elektronenhülle bezeichnet
Bei einem neutralen Atom beträgt die durchschnittliche Bindungsenergie der
Elektronen der Hülle etwa
Sie nimmt daher mit steigender Teilchenzahl erheblich zu im Gegensatz zur durchschnittlichen Bindungsenergie pro Nukleon im Kern
Zur Erklärung wird angeführt dass zwischen Nukleonen nur Bindungskräfte kurzer Reichweite wirken die kaum über die benachbarten Teilchen hinausreichen während die Hülle durch die elektrostatische Anziehungskraft gebunden ist die als langreichweitige Wechselwirkung mit größerem Abstand vom Kern vergleichsweise schwach abnimmt
Abgesehen von der Masse die zu über <num> Prozent im Atomkern konzentriert ist ist die Atomhülle für praktisch alle äußeren Eigenschaften des Atoms verantwortlich
Der Begriff Atommodell bezieht sich daher im engeren Sinn meist nur auf die Hülle siehe Liste der Atommodelle
Ein einfaches Atommodell ist das Schalenmodell nach dem die Elektronen sich in bestimmten Schalen um den Kern anordnen in denen jeweils für eine bestimmte Anzahl Elektronen Platz ist
Allerdings haben diese Schalen weder einen bestimmten Radius noch eine bestimmte Dicke sondern überlappen und durchdringen einander teilweise
Wesentliche Eigenschaften der Hülle sind oben unter Quantenmechanische Atommodelle und Erklärung grundlegender Atomeigenschaften dargestellt
In den nachfolgenden Abschnitten folgen weitere Details
Interpretation grundlegender Atomeigenschaften im Rahmen des Schalenmodells
Die Atomhülle bestimmt die Stärke und Abstandsabhängigkeit der Kräfte zwischen zwei Atomen
Im Abstandsbereich mehrerer Atomdurchmesser polarisieren sich die gesamten Atomhüllen wechselseitig sodass durch elektrostatische Anziehung anziehende Kräfte die Van-der-Waals-Kräfte entstehen
Sie bewirken vor allem die Kondensation der Gase zu Flüssigkeiten also einen Wechsel der Aggregatzustände
Die näherungsweise Inkompressibilität der Flüssigkeiten und Festkörper hingegen beruht darauf dass alle Atome bei starker Annäherung einander stark abstoßen sobald sich ihre Hüllen im Raum merklich überschneiden und daher verformen müssen
Außer im Fall zweier Wasserstoffatome die jeweils nur ein Elektron in der Hülle haben spielt die elektrostatische Abstoßung der beiden Atomkerne dabei nur eine geringe Rolle
In einem mittleren Abstandsbereich zwischen dem Vorherrschen der schwach anziehenden Van-der-Waals-Kräfte und der starken Abstoßung kommt es zwischen zwei oder mehr zueinander passenden Atomhüllen zu einer besonders starken Anziehung der chemischen Bindung
Bei Atomen bestimmter Elemente kann diese Anziehung zu einem stabilen Molekül führen das aus Atomen in zahlenmäßig genau festgelegter Beteiligung und räumlicher Anordnung aufgebaut ist
Die Moleküle sind die kleinsten Stoffeinheiten der chemischen Verbindungen also der homogenen Materialien in all ihrer Vielfalt
Vermittelt über die Hüllen ihrer Atome ziehen auch Moleküle einander an
Ein fester Körper entsteht wenn viele Moleküle sich aneinander binden und dabei weil es energetisch günstig ist eine feste Anordnung einhalten
Ist diese Anordnung regelmäßig bildet sich ein Kristallgitter
Infolge dieser Bindung ist der feste Körper nicht nur weitgehend inkompressibel wie eine Flüssigkeit sondern im Unterschied zu dieser auch auf Zug belastbar und deutlich weniger leicht verformbar
Verbinden sich Atome metallischer Elemente miteinander ist ihre Anzahl nicht festgelegt und es können sich nach Größe und Gestalt beliebige Körper bilden
Vor allem chemisch reine Metalle zeigen dann meist auch eine große Verformbarkeit
Verbindungen verschiedener Metalle werden Legierung genannt
Die Art der Bindung von Metallatomen erklärt warum Elektronen sich fast frei durch das Kristallgitter bewegen können was die große elektrische Leitfähigkeit und Wärmeleitfähigkeit der Metalle verursacht
Zusammengefasst ergeben sich aus der Wechselwirkung der Atomhüllen miteinander die mechanische Stabilität und viele weitere Eigenschaften der makroskopischen Materialien
Aufgrund des unscharfen Randes der Atomhülle liegt die Größe der Atome nicht eindeutig fest
Die als Atomradien tabellierten Werte sind aus der Bindungslänge gewonnen das ist der energetisch günstigste Abstand zwischen den Atomkernen in einer chemischen Bindung
Insgesamt zeigt sich mit steigender Ordnungszahl eine in etwa periodische Variation der Atomgröße die mit der periodischen Variation des chemischen Verhaltens gut übereinstimmt
Im Periodensystem der Elemente gilt allgemein dass innerhalb einer Periode also einer Zeile des Systems eine bestimmte Schale aufgefüllt wird
Von links nach rechts nimmt die Größe der Atome dabei ab weil die Kernladung anwächst und daher alle Schalen stärker angezogen werden
Wenn eine bestimmte Schale mit den stark gebundenen Elektronen gefüllt ist gehört das Atom zu den Edelgasen
Mit dem nächsten Elektron beginnt die Besetzung der Schale mit nächstgrößerer Energie was mit einem größeren Radius verbunden ist
Innerhalb einer Gruppe also einer Spalte des Periodensystems nimmt die Größe daher von oben nach unten zu
Dementsprechend ist das kleinste Atom das Heliumatom am Ende der ersten Periode mit einem Radius von <num> pm während eines der größten Atome das Caesiumatom ist das erste Atom der <num> Periode
Es hat einen Radius von <num> pm
Erklärung der Atomeigenschaften im Rahmen des Orbitalmodells
Die dem Schalenmodell zugrundeliegenden Elektronenschalen ergeben sich durch die Quantisierung der Elektronenenergien im Kraftfeld des Atomkerns nach den Regeln der Quantenmechanik
Um den Kern herum bilden sich verschiedene Atomorbitale das sind unscharf begrenzte Wahrscheinlichkeitsverteilungen für mögliche räumliche Zustände der Elektronen
Jedes Orbital kann aufgrund des Pauli-Prinzips mit maximal zwei Elektronen besetzt werden dem Elektronenpaar
Die Orbitale die unter Vernachlässigung der gegenseitigen Abstoßung der Elektronen und der Feinstruktur theoretisch die gleiche Energie hätten bilden eine Schale
Die Schalen werden mit der Hauptquantenzahl durchnummeriert oder fortlaufend mit den Buchstaben K L M bezeichnet
Genauere Messungen zeigen dass ab der zweiten Schale nicht alle Elektronen einer Schale die gleiche Energie besitzen
Falls erforderlich wird durch die Nebenquantenzahl oder Drehimpulsquantenzahl eine bestimmte Unterschale identifiziert
Sind die Orbitale angefangen vom energetisch niedrigsten so weit mit Elektronen besetzt dass die gesamte Elektronenzahl gleich der Protonenzahl des Kerns ist ist das Atom neutral und befindet sich im Grundzustand
Werden in einem Atom ein oder mehrere Elektronen in energetisch höherliegende Orbitale versetzt ist das Atom in einem angeregten Zustand
Die Energien der angeregten Zustände haben für jedes Atom wohlbestimmte Werte die sein Termschema bilden
Ein angeregtes Atom kann seine Überschussenergie abgeben durch Stöße mit anderen Atomen durch Emission eines der Elektronen Auger-Effekt oder durch Emission eines Photons also durch Erzeugung von Licht oder Röntgenstrahlung
Bei sehr hoher Temperatur oder in Gasentladungen können die Atome durch Stöße Elektronen verlieren siehe Ionisationsenergie es entsteht ein Plasma so z B
in einer heißen Flamme oder in einem Stern
DateiFraunhofer lines DEsvg Da die Energien der Quanten der emittierten Strahlung je nach Atom bzw Molekül und den beteiligten Zuständen verschieden sind lässt sich durch Spektroskopie dieser Strahlung die Quelle im Allgemeinen eindeutig identifizieren
Beispielsweise zeigen die einzelnen Atome ihr elementspezifisches optisches Linienspektrum
Bekannt ist etwa die Natrium-D-Linie eine Doppellinie im gelben Spektralbereich bei <num> nm und <num> nm die auch in nebenstehender Abbildung mit D-<num> bezeichnet wird
Ihr Aufleuchten zeigt die Anwesenheit von angeregten Natrium-Atomen an sei es auf der Sonne oder über der Herdflamme bei Anwesenheit von Natrium oder seinen Salzen
Da diese Strahlung einem Atom auch durch Absorption dieselbe Energie zuführen kann lassen sich die Spektrallinien der Elemente sowohl in Absorptions- als auch in Emissionsspektren beobachten
Diese Spektrallinien lassen sich auch verwenden um Frequenzen sehr präzise zu vermessen beispielsweise für Atomuhren
Obwohl Elektronen sich untereinander elektrostatisch abstoßen können zusätzlich bis zu zwei weitere Elektronen gebunden werden wenn es bei der höchsten vorkommenden Elektronenenergie noch Orbitale mit weiteren freien Plätzen gibt siehe Elektronenaffinität
Chemische Reaktionen d h
die Verbindung mehrerer Atome zu einem Molekül oder sehr vieler Atome zu einem Festkörper werden dadurch erklärt dass ein oder zwei Elektronen aus einem der äußeren Orbitale eines Atoms Valenzelektronen unter Energiegewinn auf einen freien Platz in einem Orbital eines benachbarten Atoms ganz hinüberwechseln Ionenbindung oder sich mit einer gewissen Wahrscheinlichkeit dort aufhalten kovalente Bindung durch ein bindendes Elektronenpaar
Dabei bestimmt die Elektronegativität der Elemente bei welchem Atom sich die Elektronen wahrscheinlicher aufhalten
In der Regel werden chemische Bindungen so gebildet dass die Atome die Elektronenkonfiguration eines Edelgases erhalten Edelgasregel
Für das chemische Verhalten des Atoms sind also Form und Besetzung seiner Orbitale entscheidend
Da diese allein von der Protonenzahl bestimmt werden zeigen alle Atome mit gleicher Protonenzahl also die Isotope eines Elements nahezu das gleiche chemische Verhalten
Nähern sich zwei Atome über die chemische Bindung hinaus noch stärker an müssen die Elektronen eines Atoms wegen des Pauli-Prinzips auf freie aber energetisch ungünstige Orbitale des anderen Atoms ausweichen was einen erhöhten Energiebedarf und damit eine abstoßende Kraft nach sich zieht
Wechselwirkung zwischen Kern und Hülle
Mit großer Genauigkeit wird die Wechselwirkung zwischen Kern und Hülle schon durch den einfachen Ansatz beschrieben in dem der Kern eine punktförmige Quelle eines elektrostatischen Felds nach dem Coulomb-Gesetz darstellt
Alle genannten Atommodelle beruhen hierauf
Aufgrund zusätzlicher Effekte die in erweiterten Modellen behandelt werden sind nur extrem kleine Korrekturen nötig die unter dem Namen Hyperfeinstruktur zusammengefasst werden
Zu berücksichtigen sind hier drei Effekte erstens die endliche Ausdehnung die jeder Kern besitzt zweitens eine magnetische Dipolwechselwirkung wenn sowohl Kern als auch Hülle eine Drehimpulsquantenzahl von mindestens
haben und drittens eine elektrische Quadrupolwechselwirkung wenn beide Drehimpulsquantenzahlen mindestens <num> sind
Die endliche Ausdehnung des Kerns - verglichen mit einer theoretischen Punktladung - bewirkt eine schwächere Anziehung derjenigen Elektronen deren Aufenthaltswahrscheinlichkeit bis in den Kern hineinreicht
Betroffen sind nur s-Orbitale Bahndrehimpuls Null
Bei Atomen mittlerer Ordnungszahl liegt die Korrektur in der Größenordnung von <num> Prozent
Die magnetischen Dipol- bzw elektrischen Quadrupol-Momente von Hülle und Kern bewirken eine Kopplung mit der Folge dass die Gesamtenergie eines freien Atoms je nach Quantenzahl seines Gesamtdrehimpulses äußerst geringfügig aufgespalten ist
Im H-Atom beträgt die Aufspaltung etwa ein Millionstel der Bindungsenergie des Elektrons siehe <num>-cm-Linie
Anschaulich gesprochen hängt die Energie davon ab in welchem Winkel die Achsen des magnetischen Dipolmoments bzw elektrischen Quadrupolmoments von Kern und Hülle zueinander stehen
Auch bei Atomen in Flüssigkeiten und Festkörpern treten diese Wechselwirkungen in entsprechend modifizierter Form auf
Trotz der Kleinheit der dadurch verursachten Effekte haben sie eine große Rolle in der Atom- und Kernforschung gespielt und sind in besonderen Fällen auch bei modernen Anwendungen wichtig
Beobachtung
Indirekte Beobachtung
Indirekte Möglichkeiten Atome zu erkennen beruhen auf der Beobachtung der von ihnen ausgehenden Strahlung
So kann aus Atomspektren beispielsweise die Elementzusammensetzung entfernter Sterne bestimmt werden
Die verschiedenen Elemente lassen sich durch charakteristische Spektrallinien identifizieren die auf Emission oder Absorption durch Atome des entsprechenden Elements in der Sternatmosphäre zurückgehen
Gasentladungslampen die dasselbe Element enthalten zeigen diese Linien als Emissionslinien Auf diese Weise wurde z B
<num> Helium im Spektrum der Sonne nachgewiesen - über <num> Jahre bevor es auf der Erde entdeckt wurde
Ein Atom kann ionisiert werden indem eines seiner Elektronen entfernt wird
Die elektrische Ladung sorgt dafür dass die Flugbahn eines Ions von einem Magnetfeld abgelenkt wird
Dabei werden leichte Ionen stärker abgelenkt als schwere
Das Massenspektrometer nutzt dieses Prinzip um das Masse-zu-Ladung-Verhältnis von Ionen und damit die Atommassen zu bestimmen
Die Elektronenenergieverlustspektroskopie misst den Energieverlust eines Elektronenstrahls bei der Wechselwirkung mit einer Probe in einem Transmissionselektronenmikroskop
Beobachtung einzelner Atome
DateiAtomic resolution Au<num>JPG Eine direkte Abbildung die einzelne Atome erkennen lässt wurde erstmals <num> mit dem Feldionenmikroskop oder Feldemissionsmikroskop erzielt
Auf einem kugelförmigen Bildschirm in dessen Mittelpunkt sich eine extrem feine Nadelspitze befindet erscheint ein etwa millionenfach vergrößertes Bild Darin sind die obersten Atome die die Spitze bilden nebeneinander als einzelne Lichtpunkte zu erkennen
Dies kann heute auch im Physikunterricht an der Schule vorgeführt werden
Das Bild entsteht in Echtzeit und erlaubt z B
die Betrachtung der Wärmebewegung einzelner Fremdatome auf der Spitze
Auch das Rastertunnelmikroskop ist ein Gerät das einzelne Atome an der Oberfläche eines Körpers sichtbar macht
Es verwendet den Tunneleffekt der es Teilchen erlaubt eine Energiebarriere zu passieren die sie nach klassischer Physik nicht überwinden könnten
Bei diesem Gerät tunneln Elektronen zwischen einer elektrisch leitenden Spitze und der elektrisch leitenden Probe
Bei Seitwärtsbewegungen zur Abrasterung der Probe wird die Höhe der Spitze so nachgeregelt dass immer derselbe Strom fließt
Die Bewegung der Spitze bildet die Topographie und Elektronenstruktur der Probenoberfläche ab
Da der Tunnelstrom sehr stark vom Abstand abhängt ist die laterale Auflösung viel feiner als der Radius der Spitze manchmal atomar
Eine tomographische Atomsonde erstellt ein dreidimensionales Bild mit einer Auflösung unterhalb eines Nanometers und kann einzelne Atome ihrem chemischen Element zuordnen
Literatur
Weblinks
HydrogenLab Wie sieht ein Atom aus
Übersicht über die verschiedenen Atommodelle
Geschichtlicher Überblick zum Atombegriff aus naturphilosophischer Perspektive von Brigitte Falkenburg im Online-Lexikon naturphilosophischer Grundbegriffe
Einzelnachweise
Charles Kittel Einführung in die Festkörperphysik <num> Auflage <num> Verlag R Oldenbourg München S <num>
F Dannemann Die Naturwissenschaften in ihrer Entwicklung und in ihrem Zusammenhange Bd <num> Verlag W Engelmann <num> S <num>
Loschmidt Zur Grösse der Luftmoleküle In Sitzungsberichte der kaiserlichen Akademie der Wissenschaften Wien Band <num> <num> Abt II S <num>-<num>
Walther Kossel Über Molekülbildung als Frage des Atombaus Annalen der Physik Bd <num> <num> S <num>-<num> doi<num>andp<num>
G Baur et al Production of antihydrogen In
Physics Letters B <num> Nr <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> Preprint online
DateiAuscultation of the anterior Thoraxjpg DateiRod of Asclepius<num>svg Ein Arzt Mehrzahl Ärzte weiblich Ärztin Ärztinnen ist ein medizinisch ausgebildeter und zur Ausübung der Heilkunde zugelassener Heilkundiger
Der Arztberuf gilt der Vorbeugung Prävention Erkennung Diagnose Behandlung Therapie und Nachsorge von Krankheiten Leiden oder gesundheitlichen Beeinträchtigungen und umfasst auch ausbildende Tätigkeiten
Der Arzt stellt sich damit in den Dienst der Gesundheit und ist bei seinem Handeln moralischen und ethischen Grundsätzen verpflichtet vergleiche Genfer Deklaration des Weltärztebundes
Die Vielfalt an Krankheiten und Behandlungsmöglichkeiten hat in der Humanmedizin und Tierheilkunde mit der Zeit zu einer großen Anzahl von Fachgebieten und weiteren Differenzierungen geführt
Liste medizinischer Fachgebiete
Bezeichnungen
Die Bezeichnung Arzt
zog während des Mittelalters aus der lateinischen Gelehrtensprache ins Deutsche ein und zwar über die latinisierte Variante
spätlateinisch auch
des griechischen
klassische Aussprache
Oberarzt Leibarzt seit dem <num> Jahrhundert die Amtsbezeichnung von Leibärzten bei Hofe und von öffentlich bestallten Gemeindeärzten einer Zusammensetzung aus
Kommando und
In vielen fachsprachlichen Komposita tritt das ursprüngliche griechische Wort
bzw die latinisierte Form
als Wortbestandteil auf iatrogen durch ärztliches Handeln verursacht
Psychiater
Seelenarzt usw Über mittelhochdeutsche Vermittlung gelangte das Wort in andere Sprachen so
Die germanische Bezeichnung für den Heilberuf
ist beispielsweise im dänischen
im schwedischen
im englischen
vgl Balds Leechbook oder im deutschen Familiennamen Lachmann erhalten und hat sich in andere Sprachen verbreitet z B
Im polnischen
und tschechischen
ist die germanische Wurzel mit einem slawischen Suffix -arz -ař verbunden
Die lateinische Bezeichnung
ursprünglich als allgemeine vom Ausbildungsstand unabhängige Berufszeichnung seit dem <num> Jahrhundert dann vom
bzw
dem Wundarzt unterschieden oder eine davon abgeleitete Form findet sich vor allem in den romanischen Sprachen etwa
aber unter romanischem Einfluss auch in anderen Sprachen
Die Bezeichnung
meinte meist einen akademisch ausgebildeten Arzt
In vielen Sprachen wird der Arzt umgangssprachlich nach seinem zumeist geführten akademischen Grad Doktor
genannt
Gelegentlich ebenfalls als Arzt wurden vor allem ab dem <num> Jahrhundert volksmedizinisch arbeitende Laienärzte bezeichnet
Zum Arztberuf
Geschichte
Die Funktion des Arztes ist eine der ältesten der Menschheit Medizingeschichtlich gesehen entstand der Arztberuf aus dem Stand der Heilkundigen die schon unter den Priestern des Altertums zu finden waren
Erste schriftliche Belege des Arztberufs stammen aus Mesopotamien und wurden im <num> Jahrtausend v Chr verfasst
Die Ausbildung von Ärzten der Antike fand in sogenannten Ärzteschulen z B
Schule von Kos Schule von Knidos Alexandrinische Schule statt die sich hinsichtlich ihrer Wissenvermittlung an unterschiedlichen ärztlichen Theorien z B
Methodiker Pneumatiker Hippokratiker und philosophischen Strömungen z B
Epikureer Stoiker ausrichteten
Die moderne Ausbildung von Ärzten begann im <num> Jahrhundert mit der Erweiterung des naturwissenschaftlichen Wissens und der Einführung von systematischem praktischem Unterricht am Krankenbett
Eine einheitliche Prüfungsordnung siehe auch Approbationsordnung für Ärzte gab es in Deutschland erstmals <num>
<num> war der Anteil der Ärztinnen an der Gesamtzahl der berufstätigen Ärzte bereits auf <num> Prozent gestiegen wenngleich der Anteil der Frauen <num> zu Beginn des Studiums bei fast zwei Dritteln lag
Gesundheit und Krankheitsverhalten
Während die körperliche Gesundheit von männlichen Ärzten mit derjenigen der allgemeinen männlichen Bevölkerung vergleichbar zu sein scheint scheint die körperliche Gesundheit von Ärztinnen besser zu sein als die der allgemeinen weiblichen Bevölkerung
Hinsichtlich der psychischen Gesundheit fällt auf dass Depressionen und Suchterkrankungen bei Ärzten häufiger vorkommen als in der restlichen Bevölkerung
Ein weiteres bei Medizinern häufig auftretendes Krankheitsbild ist das Burnout-Syndrom das bereits bei Medizinstudenten in einer erhöhten Rate nachgewiesen werden kann
Mehrere Studien zeigten eine gegenüber der allgemeinen Bevölkerung erhöhte Suizidrate unter Ärzten
Das gegenüber der Normalbevölkerung erhöhte relative Risiko einen Suizid zu begehen lag für Ärzte bei <num>-<num> und für Ärztinnen bei <num>-<num> Da in den Studien meist nur eine kleine Zahl von Suiziden untersucht wurde waren die Vertrauensbereiche des wahren Wertes der Risikoerhöhung weit
Es wird vermutet dass eine beträchtliche Anzahl von Selbstmorden nicht erfasst wird da diese fälschlicherweise als Vergiftungen oder Unfälle deklariert werden
Von den verschiedenen beruflichen Spezialisierungen sind insbesondere Psychiater Anästhesisten und Allgemeinmediziner von einer erhöhten Suizidrate betroffen
Als Ursachen des erhöhten Suizidrisikos werden verschiedene Faktoren diskutiert
Ein Persönlichkeitsprofil mit zwanghaften Zügen kann infolge der beruflichen Anforderungen zu einer depressiven Störung führen
Die Schwierigkeiten Familie und Karrierewunsch miteinander zu vereinbaren können insbesondere bei Ärztinnen zu Erschöpfung und Depression führen
Suchterkrankungen wie beispielsweise Alkohol- Drogen- und Medikamentenabhängigkeit die bei Ärzten häufiger auftreten gehen ihrerseits meistens mit Depressionen und einer erhöhten Suizidrate einher
Dieses für Ärzte und Ärztinnen festgestellte Risikoprofil ist berufsunabhängig und trifft für die meisten Suizidenten zu
Psychische Probleme korrelieren häufig mit Zeitdruck und mangelnder Autonomie am Arbeitsplatz sowie belastenden Patient-Arzt-Beziehungen
Ärzte werden seltener krankgeschrieben und zeigen eine mangelhafte Inanspruchnahme medizinischer Versorgungsleistungen
Häufig behandeln sich Ärzte selbst
Die eigenständige Behandlung eigener psychischer Störungen ist jedoch häufig ineffektiv
Schutzpatron
Die heiligen Zwillingsbrüder Cosmas und Damian gelten wegen ihres Arztberufs unter anderem auch als Schutzpatrone der Ärzte Ein weiterer Schutzpatron ist der heilige Pantaleon einer der Vierzehn Nothelfer
Nationales
Deutschland
Rechtliche Einordnung des Berufes
Der Arzt gehört in Deutschland seit <num> zu den Freien Berufen und ist seit <num> ein klassischer Kammerberuf
Ärzte unterliegen einer staatlichen Überwachung der Zulassung Approbation in Deutschland s u in anderen EU-Ländern und unter anderem dem Arztwerberecht welches weitgehende Einschränkungen in der Publikation und Veröffentlichungen bedeutet
Ärzte haften ihren Patienten zwar in der Regel nicht auf Erfolg ihres Handelns können ihnen aber unter dem Gesichtspunkt der Arzthaftung zum Schadenersatz verpflichtet sein
Die freie Ausübung der Heilkunde ist in Deutschland nur approbierten Ärzten erlaubt
Mit festgelegten Einschränkungen dürfen auch Heilpraktiker Kranke behandeln wobei die klar festgelegten Grenzen einzuhalten sind
Ausnahmsweise werden spezielle Bereiche der Diagnostik und Therapie auch meist auf Veranlassung von Ärzten von Angehörigen der Gesundheitsfachberufe durchgeführt
Ab dem Zeitpunkt der ärztlichen Approbation darf der Arzt die gesetzlich geschützte Bezeichnung Arzt führen und erhält mit ihr die staatliche Erlaubnis zur eigenverantwortlichen und selbstständigen ärztlichen Tätigkeit
Die bundesweit einheitliche Approbationsordnung regelt das zuvor erfolgreich abzuleistende mindestens sechsjährige Medizinstudium bezüglich der Dauer und der Inhalte der Ausbildung in den einzelnen Fächern sowie der Prüfungen
Das Studium der Medizin umfasst u a drei Examina sowie ein Jahr praktische Tätigkeit sogenanntes Praktisches Jahr Von Oktober <num> bis Oktober <num> war zur Erlangung der Vollapprobation zusätzlich eine <num>-monatige gering bezahlte Tätigkeit als Arzt im Praktikum unter Aufsicht eines approbierten Arztes gesetzlich vorgeschrieben
Meist arbeitet ein approbierter Arzt für mehrere Jahre als Assistenzarzt an von der Landesärztekammer anerkannten Weiterbildungsstätten wie <num> Krankenhäuser <num>
waren <num> in privater Trägerschaft seltener einzelne Großpraxen um sich auf einem oder mehreren Spezialgebieten der Medizin anrechenbar weiterzubilden und eventuell nach zusätzlich mindestens vierjähriger Weiterbildungszeit eine Facharztprüfung abzulegen
Die Anforderungen dazu sind in den Weiterbildungsordnungen der Landesärztekammern geregelt Niedergelassene Ärzte arbeiten in freier Praxis gegebenenfalls auch mit mehreren Ärzten in einer Berufsausübungsgemeinschaft früher Gemeinschaftspraxis oder Praxisgemeinschaft s a
Vertragsarztrechtsänderungsgesetz
Honorarärzte arbeiten auf Honorarbasis für verschiedene Kliniken oder niedergelassene Ärzte
Jeder Arzt ist meldepflichtiges Pflichtmitglied der Ärztekammer des Bundeslandes in deren Gebiet er wohnt bzw seine ärztliche Tätigkeit ausübt
Im Jahr <num> waren in Deutschland bei den Landesärztekammern <num> Ärzte gemeldet Zur Behandlung von Versicherten der gesetzlichen Krankenversicherungen benötigt der Arzt eine Zulassung Facharzt in eigener Praxis oder Ermächtigung als Arzt in einem Krankenhaus oder ähnlicher Institution und ist dann auch Pflichtmitglied der Kassenärztlichen Vereinigung seines Niederlassungsbezirks
Die kassenärztliche Zulassung besitzen <num> Ärzte Ende <num> selbstständige <num> Hausärzte und <num> Fachärzte In den Kliniken sind <num> Ärzte angestellt
Ende <num> arbeiteten <num> ausländische Ärzte in Deutschland öfter im Osten
<num> betrug die Zahl der berufstätigen Ärzte in Deutschland <num>
Strafrechtlich sind ärztliche Eingriffe der Körperverletzung gleichgesetzt
Diese ist nicht strafbar wenn die Einwilligung der behandelten Person nach einer Aufklärung vorliegt und die Handlung auf dem Stand des aktuellen medizinischen Wissens vorgenommen wird
<num> ff
StGB
Ausnahmen bestehen wenn der Patient aufgrund seines Zustandes z B
Bewusstlosigkeit nicht in der Lage ist seine Entscheidung mitzuteilen und durch die Unterlassung des Eingriffs die Gefahr von negativen gesundheitlichen Folgen oder sogar dem Tod des Patienten besteht
Zudem können eingeschränkt- oder nichteinwilligungsfähige Personen wie z B
Kinder oder in bestimmten Fällen seelisch Erkrankte auch gegen ihren Willen behandelt werden
Hierfür existieren strenge rechtliche Regelungen und Verfahrenswege bei welchen neben dem Arzt auch andere Institutionen z B
Amtsgericht oder gesetzlicher Betreuer an der Entscheidung mitwirken
Vor Inkrafttreten des Gesetzes zur Bekämpfung von Korruption im Gesundheitswesen haben niedergelassene für die vertragsärztliche Versorgung zugelassene Ärzte die Tatbestandsmerkmale des
StGB nicht erfüllt da diese laut Beschluss des Bundesgerichtshofs BGH vom <num> März <num> weder als Amtsträger i S d
<num> I Nr <num>c StGB noch als Beauftragte der gesetzlichen Krankenkassen i S d
<num> StGB handelten Die Gesetzeslücke wurde ab <num> Juni <num> geschlossen indem
StGB Bestechlichkeit im Gesundheitswesen und
StGB Bestechung im Gesundheitswesen hinzugefügt sowie
<num> und
<num> StGB geändert wurden
Die Erteilung der Approbation hängt seit dem <num> April <num> nicht mehr von der Staatsangehörigkeit ab Änderung des <num> BAÖ durch
<num> des Gesetzes zur Verbesserung der Feststellung und Anerkennung im Ausland erworbener Berufsqualifikationen
Kompetenzen und Pflichten
Die Verordnung von rezeptpflichtigen Arzneimitteln und die meisten invasiven Maßnahmen sind in Deutschland ausnahmslos dem approbierten Arzt vorbehalten
Hierbei ist er persönlich zur Einhaltung des anerkannten wissenschaftlichen Standes und medizinethischer Vorgaben verpflichtet
Die Genfer Deklaration orientierte sich <num> am Eid des Hippokrates
Weiter unterliegen Ärzte speziellen Regelungen wie dem Berufs- und Standesrecht welches auch an die Genfer Konvention anknüpft
Insbesondere ist auch im Strafrecht die Einhaltung der ärztlichen Schweigepflicht nach
<num> StGB festgehalten
Akademische Grade
In Deutschland gibt es aus historischen Gründen unterschiedliche medizinische akademische Grade
Diese weisen im Gegensatz zum Facharzttitel nicht auf eine besondere Fachkompetenz hin sondern dienen als Beleg einer wissenschaftlichen Leistung in einem medizinischen Bereich
Dr med - Hier wurde im Anschluss an das Staatsexamen oder das medizinische Diplom DDR eine medizinische Promotion durchgeführt
Im Gegensatz zu anderen Studienfächern ist es in der Medizin üblich während des Studiums die Dissertation zu beginnen
Die Promotion erfolgt erst nach dem Studienabschluss
Einzelheiten dazu regeln die Promotionsordnungen der Universitäten
Dr med dent - doctor medicinae dentariae Doktor der Zahnmedizin
Dipl-Med
- Der Grad Diplom-Mediziner aus DDR-Zeiten erworben <num> bis <num> ist noch häufig in den neuen Bundesländern anzutreffen
Nach Ansichten verschiedener Experten ist dieser Grad vom Arbeitsaufwand des Erwerbs her mit dem Dr med der Bundesrepublik in jener Zeit zu vergleichen
Dr med habil - Zur Habilitation in der Medizin sind ärztliche Tätigkeit und eigenständige Forschungsarbeit sowie das Durchlaufen des Habilitationsverfahrens notwendig
Anschließend werden die akademischen Bezeichnungen Privatdozent und gegebenenfalls nach mehreren Jahren außerplanmäßiger Professor verliehen sofern regelmäßig Lehrveranstaltungen an einer Universität angeboten werden
Für entsprechende Leistungen nicht einer Hochschule angehörender Graduierter kann die Bestellung als Honorarprofessor erfolgen
Dr sc med - Dieser der Habilitation ebenbürtige Grad - in der DDR von <num> bis <num> verliehen - wurde im Zuge der sogenannten Promotion B erworben
Behandlungszeit
Laut einer Studie des Instituts für Qualität und Wirtschaftlichkeit im Gesundheitswesen haben deutsche Ärzte trotz längerer Arbeitszeiten je Patient die kürzeste Sprechzeit in Europa
Sie liegt <num>
niedriger als der europäische Durchschnitt
Klinikärzte verbringen rund <num>
ihrer Zeit für Schreibtätigkeiten und Protokolle Stand <num><num> Laut einem Projektbericht des Statistischen Bundesamts vom August <num> wenden Arzt- Psychotherapeuten- und Zahnarztpraxen jährlich durchschnittlich <num> Tage Zeit für die Erfüllung von Informationspflichten auf wobei dieser Wert den gesamten Zeitaufwand aller Praxismitarbeiter darstellt und sämtliche Informationspflichten auch die der gemeinsamen Selbstverwaltung umfasst
Laut der deutschlandweiten MB-Online-Befragung des Marburger Bunds MB-Monitor von <num> sind <num>
der Krankenhausärzte der Auffassung dass ihnen nicht ausreichend Zeit für die Behandlung ihrer Patienten zur Verfügung steht
Einkommen
Die Einkommen von Ärzten in Deutschland variieren da das Spektrum medizinischer Tätigkeiten breit gefächert ist
Auch finden sich unter Ärzten Unterschiede bei der Arbeitszeit insbesondere zwischen klinisch tätigen bspw <num> Stdn-Schichten sowie eine hohe Anzahl an Überstunden und niedergelassenen hoher Anteil nicht-medizinischer-Tätigkeit aufgrund der Selbständigkeit
Niedergelassene Ärzte
Nach dem Bericht des Statistischen Bundesamtes über die Kostenstruktur bei Arztpraxen aus dem Jahr <num> lag der durchschnittliche Reinertrag Gesamteinnahmen abzüglich der Kosten je niedergelassenem Praxisinhaber im Jahr <num> bei <num> Euro
Um einem Mangel an Landärzten entgegenzuwirken wollte die Bundesregierung <num> in einem neuen Versorgungsgesetz das Einkommen von Landärzten erhöhen Unter einer Vielzahl von Gesetzen war das GKV-Versorgungsstrukturgesetz <num> und Juni <num> das Gesetz zur Stärkung der Versorgung in der gesetzlichen Krankenversicherung
Klinisch tätige Ärzte
Die durchschnittlichen Gehälter klinisch tätiger Ärzte unterscheiden sich stark nach den jeweiligen Positionen
Außendarstellung und Werbung
Neben den strengen rechtlichen Vorgaben zur Ausübung seines Berufs ist der Arzt auch bei der Außendarstellung bzw Werbung zu seinen Leistungen und seiner Praxis umfangreichen Verordnungen und Gesetzen unterworfen
Im Unterschied zu anderen Branchen ist Ärzten anpreisende oder vergleichende Werbung absolut verboten
Seit dem <num>
Deutschen Ärztetag <num> sind sachliche berufsbezogene Informationen über ihre Tätigkeit gestattet
Hauptkriterium ist dabei das schützenswerte Interesse des mündigen Patienten
Umstritten war ab <num> die Individuelle Gesundheitsleistung eingeführt worden
Statistiken
Ende <num> waren in Deutschland ca <num> Ärzte gemeldet davon <num> ohne ärztliche Tätigkeit siehe Abb Die Kassenzulassung besaßen <num> Hausärzte und <num> Fachärzte
In den Krankenhäusern waren <num> Ärzte angestellt
Im Jahr <num> wurden in Deutschland rund <num> berufstätige Ärzte und rund <num> Ärzte ohne ärztliche Tätigkeit gezählt
Auf durchschnittlich <num> Einwohner kam ein berufstätiger Arzt
DateiStruktur Aerzteschaft BRD <num>svg
Die chronologische Entwicklung kann aus der folgenden Tabelle und der Abbildung abgelesen werden
DateiEntwicklung Ärzteschaft BRDsvg
In der Gesamtzahl approbierter Ärzte sind auch die nicht mehr berufstätigen und die nicht ärztlich tätigen Ärzte enthalten
Die Bundesärztekammer und die Kassenärztliche Bundesvereinigung haben für Deutschland <num> Ärztinnen und Ärzte gezählt die <num> ärztlich tätig waren und damit <num> Ärzte mehr als im Vorjahr
Der Anteil von Frauen stieg weiter an und erreichte <num> <num>
nach <num>
im Vorjahr
Auch der Anteil älterer Ärzte stieg weiterhin an
<num> waren <num>
der Ärzte <num> Jahre oder älter <num> <num>
Insgesamt waren <num> <num> Ärztinnen und Ärzte in der vertragsärztlichen Versorgung also als Niedergelassene tätig selbständig oder bei einem Vertragsarzt angestellt
Arztbesuche Deutsche Erwachsene zwischen <num> und <num> Jahren gehen im Durchschnitt <num>-mal pro Jahr zum Arzt
Österreich
In Österreich ist man mit der Sponsion zunächst Doktor der gesamten Heilkunde Doctor medicinae universaeDr med univ
Mittlerweile handelt es sich entgegen der Bezeichnung nicht um einen Doktorgrad sondern um einen Diplomgrad ähnlich dem Magister oder dem Diplomingenieur
Vor dem Wintersemester <num><num> war das Medizinstudium in Österreich ein Doktoratsstudium welches auch Übergangsregelungen kannte
Der eigentliche Doktorgrad der Medizin Doctor scientae medicinae bzw Dr scient med kann seitdem im Anschluss an das Diplomstudium in einem dreijährigen Doktoratsstudium erworben werden
Selbständig als Arzt tätig werden darf man nur wenn für drei Jahre im Rahmen des Turnus verschiedene definierte Disziplinen durchlaufen wurden und die Arbeit vom jeweiligen Abteilungsvorstand positiv bewertet wurde
Danach ist eine weiter abschließende Prüfung abzulegen
Damit hat man das jus practicandi erworben also die Berechtigung zur selbständigen Berufsausübung als Arzt für Allgemeinmedizin
Alternativ kann sofort nach der Sponsion die meist sechsjährige Ausbildung zu einem Facharzt erfolgen nach der wiederum eine Prüfung abzulegen ist
Viele Fachärzte absolvieren den Turnus vor Beginn der Ausbildung ganz oder teilweise
Es hat sich in Österreich eingebürgert die Ausbildung zum Allgemeinmediziner zuvor abzuleisten
Viele Krankenhäuser nehmen nur Assistenzärzte mit abgeschlossener Turnusausbildung in Dienst da diese einen Nacht- oder Wochenenddienst alleine ableisten dürfen Ärzte aus anderen EU-Staaten können um Anerkennung als
approbierte Ärzte ansuchen
Am <num> Dezember <num> hat die EU-Kommission in ihrem Amtsblatt C<num><num> eine Änderungsmitteilung für die
Anhang <num><num> veröffentlicht wonach ab diesem Zeitpunkt sämtliche Absolventen des österreichischen Medizinstudiums bereits mit der Promotion ihr Grunddiplom abgeschlossen haben und somit innerhalb des gesamten EU- und EWR-Raumes sowie der Schweiz und Liechtenstein eine selbständige Tätigkeit bzw Ausbildung zum Facharzt unter denselben Voraussetzungen wie einheimische Mediziner aufnehmen dürfen
Bis dahin hatten Mediziner aus Österreich erst mit dem Abschließen der Ausbildung zum Allgemeinmediziner bzw Facharzt ein Anrecht auf automatische Anrechnung ihres Diploms in den übrigen Mitgliedsstaaten
Der niedergelassene Arzt gehört in Österreich zu den Freien Berufen Berufe von öffentlicher Bedeutung
Die Quote von knapp <num> Ärzten je <num> Einwohner ist mit die höchste Ärztedichte Europas und eine der höchsten weltweit
Einwohnerquote Kassenärzte Da in Österreich eine Pflichtversicherung herrscht sind <num>
der Bevölkerung Krankenkassenzahler
Die Quote ist also repräsentativ
Weiterbildung
Ärzte müssen in Österreich pro Jahr <num> Stunden Weiterbildung absolvieren was alle <num> Jahre von der Ärztekammer kontrolliert wird
Schweiz
<num> arbeiteten in der Schweiz rund <num><num> <num><num> je nach Quelle Ärzte davon rund <num><num> <num>
Frauen und <num><num> <num>
Männer <num>
im ambulanten und <num>
im stationären Sektor rund <num><num> <num>
waren Ausländer d h
ohne Schweizer Bürgerrecht
Qualifikation Fortbildung
In der Schweiz ist man nach dem mit dem Staatsexamen abgeschlossenen sechsjährigen Studium zunächst eidgenössisch diplomierter Arzt und als solcher zur Arbeit als Assistenzarzt in Spitälern Krankenhäusern und Arztpraxen befugt
Die Weiterbildung zum zur selbständigen Berufsausübung befugten Facharzt Spezialarzt dauert je nach Fach zwischen <num> praktischer Arzt und <num> Jahren nach dem Studienabschluss
Für einen Facharzttitel muss zudem eine Facharztprüfung abgelegt werden
Danach darf sich der Arzt Facharzt für Fachgebiet FMH nennen
Die jeweilige Fachgesellschaft prüft ob jeder Facharzt seiner Fortbildungspflicht je nach Fachgebiet <num>-<num> Stunden pro Jahr nachkommt ref ergänzen
Zulassung Arztpraxen
Die Zulassung zur Berufsausübung zulasten der Krankenkassen wird vom Krankenkassenzentralverband Santésuisse erteilt ist aber bei entsprechender Qualifikation nur eine Formalität
Die Erlaubnis zur Praxiseröffnung ist kantonal geregelt
Aktuell besteht aber ein Praxiseröffnungs-Stopp ref ergänzen
welcher die Berufsausübung zulasten der Krankenkassen einschränkt
Lediglich bei Bedarfsnachweis z B
bei einer Praxisübernahme ist eine Zulassung möglich ref ergänzen
Arbeitszeitgesetz für Assistenz- und Oberärzte
Seit dem <num> Januar <num> gilt nach längeren Kämpfen für die Assistenzärzte und Oberärzte an Schweizer Spitälern das landesweit gültige Arbeitszeitgesetz und damit die darin festgelegte maximale Wochenarbeitszeit von <num> Stunden Art <num> ArG Wöchentliche Höchstarbeitszeit
Sie ist zwar bedeutend höher als die allgemein übliche Arbeitszeit in der Schweiz <num>-<num> Stunden doch ein gewisser Fortschritt - bis dahin waren Arbeitsverträge mit der Formulierung Die Arbeitszeit richtet sich nach den Bedürfnissen des Spitals üblich wodurch Arbeitszeiten von oft über <num> oder <num> Stunden pro Woche ohne finanziellen Ausgleich zu leisten waren
Die Entgelte der Assistenzärzte lagen deswegen auf dem Niveau der Pflegenden im oberen Kader Pflegedienstleistungen
Hierarchie der Spitäler Berufskammern
Die Leitenden Ärzte und Chefärzte sind diesem Arbeitszeitgesetz nicht unterstellt
Auch sind sie finanziell in der Gesamtvergütung deutlich höher gestellt
Diese vor allem auch historisch bedingte hierarchische Trennung zeigen auch die getrennten Berufskammern der Spitalärzte VLSS und VSAO
Hingegen ist die ältere Ärztekammer FMH allen qualifizierten Ärzten offen wie auch die fachlichen Ärzteverbände
Die Mitgliedschaft ist freiwillig im Gegensatz zu anderen Ländern wie Deutschland oder Österreich
Löhne Einkommen
Referenzen FMH
NZZ
VSAO
Zwar herrscht in der Schweiz immer noch <num><num> kaum Transparenz bezüglich der Einkommensverhältnisse - im allgemeinen und auch im ärztlichen Bereich
Wobei gilt - je höher gestellt desto weniger Transparenz
Jedoch sickern zuverlässige Angaben durch
So bemühen sich die Spitalleitungen neuerdings um mehr Transparenz
Wie das Zürcher Universitätsspital welches zurzeit prüft ob und in welcher Form es die Ärztelöhne künftig offenlegen soll
Die Hälfte der Ärzte in der Schweiz arbeiten in den Spitälern
Besonders gut bezahl sind dort Radiologen Kardiologen Gastroenterologen Intensivmediziner und Urologen
Am unteren Ende der Lohnskala stehen Psychiater Kinderärzte und Ärzte aus dem Bereich Physikalische Medizin und Rehabilitation
Die Normallöhne betragen p a
Oberarzt - zwischen <num><num> und <num><num> CHF
leitender Arzt - zwischen <num><num> und <num><num> CHF
Chefarzt - zwischen <num><num> und <num><num> CHF
Diese Angaben eines Beratungsunternehmens decken sich mit denjenigen des Vereins der Leitenden Spitalärzte der Schweiz VLSS - in einer seiner Umfragen deklarierten die Kaderärzte folgende durchschnittlichen Löhne
Chefärzte - rund <num><num> CHF
leitende Ärzte - rund <num><num> CHF
Zu den Grundlöhnen und Boni kommen besonders bei Kaderärzten Zusatzhonorare aus Behandlungen von zusatzversicherten Patienten im stationären Bereich sowie bei Grund- und Zusatzversicherten im spitalambulanten Bereich
Die können bei Chefärzten bis zum <num>-Fachen des Grundlohns betragen
Einzelne Chefärzte kommen so auf Jahreslöhne von <num> Millionen Franken oder mehr sagt ein Berater der auch bemängelt dass die Chefärzte oft selbst darüber bestimmen können wie die Honorare verteilt werden
Siehe auch
Amtsarzt
Ärztevereinigung
Betriebsarzt
Kreisarzt
Leibarzt
Notarzt
Sanitätsoffizier
Schiffsarzt
Tierarzt
Vertragsarzt Kassenarzt
Zahnarzt
Literatur
Wolfgang U Eckart Geschichte der Medizin <num> Auflage
Springer Berlin u a <num> ISBN <num>-<num>-<num>-<num> Relativ knappe und gut lesbare wissensch
Darstellung des Gesamtthemas
Wilhelm Haberling Franz Hübotter Hermann Vierordt Bearb Biographisches Lexikon der hervorragenden Ärzte aller Zeiten und Völker <num> Auflage
Urban
Schwarzenberg Berlin Wien <num>-<num>
Markus Vieten Via medici-Buchreihe Berufsplaner Arzt oder was man mit einem Medizinstudium alles anfangen kann Thieme Verlag Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Vittoria Bucknall Suendoss Burwaiss Deborah MacDonald Kathy Charles Rhys Clement Mirror mirror on the ward whos the most narcissistic of them all
Pathologic personality traits in health care
In Canadian Medical Association Journal <num> <num> S <num>-<num>
Ralf Bröer MedizinalgesetzgebungMedizinrecht In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte Walter de Gruyter Berlin
New York <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin
New York <num> ISBN <num>-<num>-<num>-<num> insbesondere S <num>-<num> Stichworte Arzt
und S <num>-<num> Ausbildung ärztliche
Giovanni Maio Arztbild In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte <num> S <num>-<num>
Reinhard Platzek Verpflichtet zu heilen
Zur Zielrichtung ärztlichen Handelns
In Dominik Groß Monika Reininger Medizin in Geschichte Philologie und Ethnologie Festschrift für Gundolf Keil Königshausen
Neumann <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Wolfgang Wegner Arzt In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte <num> S <num> f
Weblinks
Nationales
Hendrik Schneider und Thorsten Ebermann
hrr-strafrechtde
Einzelnachweise
Bernhard Dietrich Haage Medizinische Literatur des Deutschen Ordens im Mittelalter In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num> Heinrich Schipperges Zur Unterscheidung des physicus vom medicus bei Petrus Hispanus In III Congresso Nacional de Historia de la Medicina Valencia <num> III <num> S <num>-<num> Theodor Kirchhoff Ueberblicke über die Geschichte der deutschen Irrenpflege im Mittelalter In Allgemeine Zeitschrift für Psychiatrie und psychiatrisch-gerichtliche Medizin Band <num> <num> Heft <num> S <num>-<num> hier S <num> Johann Hermann Baas Die geschichtliche Entwicklung des ärztlichen Standes und der medicinischen Wissenschaften Berlin <num>
In servanade Bernhard D Haage Wolfgang Wegner Medizin in der griechischen und römischen Antike In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin
New York <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> hier S <num> Giovanni Maio Ausbildung ärztliche Neuzeit In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin
New York <num> ISBN <num>-<num>-<num>-<num> S <num> f hier S <num> Ralf Bröer MedizinalgesetzgebungMedizinrecht In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte Walter de Gruyter Berlin
New York <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> hier S <num>
In weltde <num> Februar <num> R Tyssen Health problems and the use of health services among physicians a review article with particular emphasis on Norwegian studies In
Ind Health <num><num> Okt <num> S <num>-<num> PMID <num> Jürgen von Troschke Arztrolle In Bernhard Strauß Uwe Berger Jürgen von Troschke Elmar Brähler Lehrbuch Medizinische Psychologie und Medizinische Soziologie Hogrefe Verlag Göttingen <num> ISBN <num>-<num>-<num>-<num> S <num> T L Schwenk L Davis L A Wimsatt
In JAMA Band <num> Nummer <num> September <num> S <num>-<num>
doi<num>jama<num> PMID <num> Thomas Bronisch Suizidalität der Psychotherapeuten In Otto F Kernberg Birger Dulz Jochen Eckert WIR Psychotherapeuten <num> Auflage Schattauer Stuttgart <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> E Schernhammer Taking their own lives - the high rate of physician suicide In
The New England Journal of Medicine Band <num> Nummer <num> Juni <num> S <num>-<num>
doi<num>NEJMp<num> PMID <num> K Püschel S Schalinski Zu wenig Hilfe für sich selbst - Ärzte in Suizidgefahr In Archiv für Kriminologie Band <num> Nummer <num>-<num> Sep-Okt <num> S <num>-<num>
PMID <num> C Reimer S Trinkaus H B Jurkat Suizidalität bei Ärztinnen und Ärzten In Psychiatrische Praxis Band <num> Nummer <num> November <num> S <num>-<num>
doi<num>s-<num>-<num> PMID <num> M Wolfersdorf Suicide and suicide prevention for female and male physicians In MMW Fortschr Med <num><num>-<num> <num> Jun <num> S <num>-<num> PMID <num> Friedbert Ficker Schutzpatrone der Ärzte und Apotheker In Bayerische Staatszeitung Band <num> Nr <num> Heimatbeilage Unser Bayern <num> Ralf Bröer MedizinalgesetzgebungMedizinrecht S <num>
In bundesaerztekammerde <num> Oktober <num> abgerufen am <num> November <num>
In bundesaerztekammerde abgerufen am <num> November <num>
In bundesaerztekammerde abgerufen am <num> November <num>
In bundesaerztekammerde <num> Dezember <num> abgerufen am <num> November <num> Zahl der Woche In FAS <num> April <num> S C<num> BGH-GS Beschl v <num> März <num> - GSSt <num><num> BeckRS <num> <num> In openjurde Änderung
<num> Bundesärzteordnung vom <num> April <num> buzerde Pressemitteilung
In iqwigde
Teil I Kapitel <num> Zusammenfassung S <num>
PDF Statistisches Bundesamt Destatis <num><num>
In Rheinische Post <num> Mai <num> Gehälter in Kliniken nach Positionen praktischarztde
In arzt-und-apothekenet abgerufen am <num> Februar <num> may EB Ärztestatistik - Mehr Ärzte Trend zur Anstellung In
Deutsches Ärzteblatt Jahrgang <num> Heft <num> <num> April <num> S A<num> N Weber
In Spiegel Online <num> September <num> wegweiseracat
In
Amtsblatt der Europäischen Union <num> Dezember <num> <num> hatte in Europa nur Griechenland eine höhere Ärztedichte als Österreich OECD <num> Angabe nach Ärztinnen und Ärzte Bedarf und Ausbildungsstellen <num> bis <num> Papier zu einer Studie der Gesundheit Österreich GmbH im Auftrag des Gesundheitsministeriums und Wissenschafts- und Forschungsministeriums in Kooperation mit der Österreichischen Ärztekammer Pressekonferenz <num> Juli <num> Pressezentrum Sozialministerium Abschnitt Bestandsanalyse S <num>
bmggvat Ärzte nicht zu Reanimationsschulung verpflichtet orfat <num> Mai <num> abgerufen am <num> Mai <num>
Web der Verbindung der Schweizer Ärztinnen und Ärzte FMH fmhch
Web des Bundesamtes für Gesundheit BAG bagadminch Art <num> Wöchentliche Höchstarbeitszeit in SR <num> Bundesgesetz über die Arbeit in Industrie Gewerbe und Handel Arbeitsgesetz ArG in Systematischer Sammlung des Bundesrechts SR auf adminch Arbeitsgesetz Assistenz- und Oberärzte auf Web des VSAO Verband Schweizerischer Assistenz- und Oberärztinnen und -ärzte vsaoch Arbeitszeit in der Schweiz auf Web des Grenzgänger-Arbeitnehmer-Arbeitgeber-Verbands GAAV gaavde gaavch
Web FMH fmhch
PDF Editorial Schweizerische Ärztezeitung Nr <num> <num> auf Web FMH fmhch
PDF Editorial Schweizerische Ärztezeitung Nr <num>-<num> <num> auf Web FMH fmhch Simon Hehli Jan Hudec
In
NZZ <num><num> VSAO Verband Schweizerischer Assistenz- und Oberärztinnen und -ärzte vsaoch
VSAO Zürich auf vsao-zhch
DateiDa Vinci Vitruve Luc Viatour <num>svg Anthropologie im <num> Jahrhundert als anthropologia gebildet aus
und
-logie Menschenkunde Lehre vom Menschen ist die Wissenschaft vom Menschen
Sie wird im deutschen Sprachraum und in vielen europäischen Ländern vor allem als Naturwissenschaft verstanden
Die naturwissenschaftliche oder Physische Anthropologie betrachtet den Menschen im Anschluss an die Evolutionstheorie von Charles Darwin als biologisches Wesen
Dieser naturalistischen Betrachtung des Menschen die sich beispielsweise mit der Konstitution früher auch mit der Rassenlehre und Humangenetik und der Abstammung des Menschen befasst stehen verschiedene andere Ansätze gegenüber beispielsweise die philosophische Anthropologie
Hier wird der Mensch nicht nur als Objekt sondern auch als Subjekt wissenschaftlich untersucht
Dabei geht es unter anderem um qualitative Eigenschaften wie die Personalität die Entscheidungsfreiheit und die Möglichkeit zur Selbstbestimmung
In der deutschen Wissenschaftspolitik ist die Anthropologie als Kleines Fach eingestuft
Geschichte der Anthropologie
Die Bezeichnung Anthropologie geht zurück auf den deutschen Philosophen Arzt und Theologen Magnus Hundt <num>-<num> der in einem <num> erschienenen Werk schrieb Antropologium de hominis dignitate natura et proprietatibus de elementis partibus et membris humani corporis Zu den ersten Dozenten für das Fach gehörte der Anatom und Physiologe Heinrich Palmatius Leveling der die Anthropologie <num> an der Ingolstädter Universität als Vorlesung anbot
Ein Lehrstuhl für Allgemeine Naturgeschichte und Anthropologie wurde <num> in München eingerichtet
Friedrich Nasse gab von <num> bis <num> in Leipzig die aus der Zeitschrift für psychische Ärzte hervorgegangene Zeitschrift für die Anthropologie heraus Auf den ersten eigenständigen Lehrstuhl Deutschlands für physische Anthropologie wurde am <num> August <num> Johannes Ranke berufen dem <num> der Schweizer Rudolf Martin <num>-<num> folgte der <num> Direktor des Anthropologischen Instituts und der Anthropologisch-Prähistorischen Staatssammlung wurde
Martin war <num> zum Extraordinarius und <num> zum Ordinarius für Anthropologie an der Universität Zürich ernannt worden
Naturwissenschaftlicher Ansatz
Biologische Anthropologie
DateiPhysical anthropologistjpg Die biologische Anthropologie ist mit ihren Teilgebieten Primatologie Evolutionstheorie Paläoanthropologie Bevölkerungsbiologie Industrieanthropologie Genetik Sportanthropologie Wachstum Auxologie Konstitution und Forensik ein Fachbereich der Humanbiologie
Ihr Ziel ist die Beschreibung Ursachenanalyse und evolutionsbiologische Interpretation der Verschiedenheit biologischer Merkmale der Hominiden Familie der Primaten die fossile und rezente Menschen einschließt
Ihre Methoden sind sowohl beschreibend als auch analytisch
Institutionen im deutschsprachigen Raum gibt es an Universitäten und an Museen in Tübingen Kiel Hamburg Berlin Göttingen Jena Gießen Mainz Ulm Freiburg im Breisgau München Zürich und Wien
Meist ist dort die Bezeichnung nur Anthropologie Zusätze wie biologisch wurden in jüngerer Zeit notwendig weil der konkurrierende US-amerikanische Begriff der
auch hier bekannt ist
Forensische Anthropologie
DateiGalton at Bertillon<num>s <num>jpg
Die forensische Anthropologie ist eine der drei gerichtlichen Wissenschaften vom Menschen neben der Rechtsmedizin und der forensischen Odontologie
Gebiete der forensischen Anthropologie
Identifizierung nach Bildern
Die meisten bearbeiteten Fälle betreffen Ordnungswidrigkeiten im Verkehr also Schnellfahrer und Rotmissachter die spektakulären Fälle betreffen Bankräuber oder auch zeitgeschichtliche Personen
Identifizierung von Skeletten und teilskelettierten Leichen auch in Massengräbern
Altersdiagnose insbesondere bei jungen Straftätern
Abstammungsgutachten
Zwillingsdiagnose
Die forensische Anthropologie dient mit den Mitteln der Anthropologie bei der Aufklärung von Verbrechen
Forensische Anthropologen haben vor allem mit der Identifikation von Bankräubern Schnellfahrern etc zu tun aber auch häufig mit stark verwesten oder vollständig skelettierten Leichen
Nicht selten sind sie die letzte Hoffnung zur Aufklärung eines Verbrechens
In Deutschland gibt es eine starke institutionelle Dominanz der Rechtsmedizin aber gerade das verhindert manchmal den Zugang zu der eigenständigen Kompetenz der Anthropologie
Geisteswissenschaftlicher Ansatz
Sozialanthropologie
Die Sozialanthropologie gilt als Wissenschaft der kulturellen und sozialen Vielfalt - oder allgemeiner als Wissenschaft vom Menschen in der Gesellschaft Sie analysiert die soziale Organisation des Menschen
Im deutschen Sprachraum war der Begriff Sozialanthropologie eine seit den <num>er Jahren gebrauchte Bezeichnung für die britische
oder die französische
wurde dann aber zugunsten der Fachbezeichnung Ethnosoziologie aufgegeben Fachbereich der Ethnologie
In den letzten Jahren ist jedoch eine Renaissance des Anthropologie-Begriffs zu beobachten die einer durch Transnationalisierungs- und Globalisierungsprozesse veränderten Forschungslandschaft Rechnung tragen möchte
Kulturanthropologie
DateiSchultuetejpg
Die Kulturanthropologie ist eine empirisch gestützte Wissenschaft von der Kultur im Sinne von menschliche Kultur Sie entwickelte sich im <num> Jahrhundert aus der Volkskunde hat ihren Schwerpunkt im Gegensatz zu dieser aber in interkulturellen ethnologischen und soziologischen Themen und Modellen
Unter den anthropologischen Fachrichtungen nimmt die Kulturanthropologie eine Mittelposition zwischen den biologisch und den philosophisch orientierten Richtungen ein sie ist in ihrem Themenspektrum am weitesten gefasst
Im deutschen Sprachraum hat sich bisher keine genauere Definition des Forschungsgegenstandes durchgesetzt
In den USA dagegen bezeichnet
cultural anthropology
die Ethnologie Völkerkunde
Im Deutschen wird die ungenaue englische Bezeichnung anthropology teils falsch mit Anthropologie übersetzt während eigentlich die Ethnologie gemeint ist
Rechtsanthropologie
Die Rechtsanthropologie bildet eine eigenständige Unterform der Kulturanthropologie
Sie untersucht Inhalt und Funktionsweisen rechtlicher Strukturen des Menschen unterschiedlicher kultureller Traditionen von Stämmen und Völkern siehe auch Rechtsethnologie
Zudem bezeichnet dieser Begriff eine rechtswissenschaftliche Forschungsrichtung die sich den naturalen Grundkonstanten von Gesetzgebung und Rechtsprechung verschrieben hat
Dabei beschäftigt sich die Rechtsanthropologie vorwiegend mit dem westlich-demokratischen Menschenbild der Verfassung das demgegenüber vom im Willen freien und eigenverantwortlich handelnden Menschen ausgeht
Dafür wählt sie zumeist einen pragmatisch-dualen Ansatz
Der Begriff Kultur gelegentlich auch der politischere Begriff der Zivilisation beschreibt dann die sozial-reale Welt in der der Mensch beide Sichtweisen vereint
Philosophische Anthropologie
Die philosophische Anthropologie ist die Disziplin der Philosophie die sich mit dem Wesen des Menschen befasst
Die moderne philosophische Anthropologie ist eine sehr junge philosophische Fachrichtung die erst im frühen <num> Jahrhundert als Reaktion auf den Verlust von Weltorientierung entstand
Mit Ausnahme von René Descartes der bereits Mitte des <num> Jahrhunderts in seinen Meditationen über die erste Philosophie <num> gewisse Zweifel am mittelalterlich-christlichen Weltbild hegt und Position zu Verhältnis von Körper und Seele bezieht
Er vermittelt ein neues philosophisches Gedankengut wie Das Denken Bewusstsein
ist es es allein kann von mir nicht abgetrennt werden ich bin ich existiere - das ist gewiss
Demnach bin ich genau genommen ein denkendes Ding d h
Geist bzw Seele bzw Verstand
Historische Anthropologie
Historische Anthropologie bezeichnet einerseits die anthropologische Forschung in der Geschichtswissenschaft andererseits eine transdisziplinäre Forschungsrichtung die die historische Veränderlichkeit von Grundphänomenen des menschlichen Daseins untersucht
Dabei bezieht sie die Geschichtlichkeit ihrer Blickrichtungen und methodischen Herangehensweisen sowie die Geschichtlichkeit ihres Gegenstandes also das Erscheinungsbild des Menschen in den unterschiedenen Epochen aufeinander
Theologische Anthropologie
Die theologische Anthropologie als Teilbereich der Systematischen Theologie deutet den Menschen aus christlich-theologischer Sicht
Dabei beschäftigt sie sich besonders mit dem Wesen des Menschen und der Bestimmung des Menschen vor Gott
Im Unterschied dazu untersucht die Religionsethnologie als Fachgebiet der Ethnologie Völkerkunde die Religionen bei den weltweit rund <num> ethnischen Gruppen und indigenen Völkern in Abgrenzung zur Religionssoziologie vor allem bei ehemals schriftlosen Kulturen
Industrieanthropologie
Die Industrieanthropologie als Disziplin der Anthropologie untersucht die Gebrauchstauglichkeit
und Benutzerfreundlichkeit von Arbeitsplätzen von Bedienelementen sowie von Produkten
Andere Ansätze und Mischformen
Anthropologie in den Sozialwissenschaften
DateiDhaka street crowdsjpg
In den Sozialwissenschaften ist die Vorstellung weit verbreitet dass der Mensch seinem Wesen nach in seinen Antrieben und Bedürfnissen unbestimmt ist weshalb erst in Vergesellschaftungsprozessen eine Orientierung und Stabilisierung des Verhaltens und Antriebslebens entstehen kann
Dieses Menschenbild bildet die allgemeine anthropologische Voraussetzung für die Analyse von sozialen Prozessen so etwa bei Karl Marx Max Weber George Herbert Mead oder Talcott Parsons
Darüber hinaus gibt es in den Sozialwissenschaften zwei klassische Menschenbilder die als analytische und idealtypische Modelle fungieren der
homo oeconomicus
der Wirtschaftswissenschaften und der
homo sociologicus
der Soziologie
Eine realistische Variante des individualistischen homo oeconomicus ist das RREEMM-Modell des Menschen allerdings wird in der sozialwissenschaftlichen Theoriebildung wegen Operationalisierungsproblemen auch weiterhin überwiegend auf die einfacheren Modelle zurückgegriffen
Ausgehend von der Einbeziehung amerikanischer Sozialforscher in den Vietnamkrieg Project Camelot wurde im Rahmen der Critical Anthropology ab <num> eine reflexive Anthropologie entwickelt Bob Scholte <num> Die Grundannahme der reflexiven Anthropologie besteht darin dass sozialwissenschaftliche Aussagen nur dann einer Kritik standhalten wenn sie die soziale und kulturelle Einbettung des Forschers und der Forschung mit bedenken reflektieren
Gemäß dem Erkenntnisinteresse jeder Anthropologie erkenne dich selbst
gnothi seauton
ist auf diesem Weg eine Unterscheidung möglich zwischen einer Sozialforschung als Informationsgewinnung über andere Menschen Ausspähen vergleiche Informationelle Selbstbestimmung oder als Beitrag zur Selbsterkenntnis des Forschers und seiner Auftraggeber
Bedeutende Ansätze zu einer reflexiven Anthropologie wurden von Michel Foucault und Pierre Bourdieu vorgelegt
Das Konzept der reflexiven Anthropologie von Gesa Lindemann schließt sich im Gegensatz dazu an die historisch-reflexive Richtung innerhalb der deutschsprachigen philosophischen Anthropologie Helmuth Plessner an Allgemeine Aussagen der philosophischen Anthropologie werden nicht als sozialtheoretisches Fundament begriffen sondern zum Gegenstand der Beobachtung gemacht
Bei diesem Ansatz geht es um die Bearbeitung der Frage wie in Gesellschaften der Kreis sozialer Personen begrenzt wird und welche Funktion der Anthropologie in der Moderne zukommt
Psychologische Anthropologie
In dem verwendeten Schema kann die Psychologie des Menschen nicht gut untergebracht werden denn die Psychologie vereint geisteswissenschaftliche biologische verhaltens- und sozialwissenschaftliche Konzepte und Methoden
Als Wissenschaft vom Erleben und Verhalten des Menschen einschließlich der biologischen bzw neurowissenschaftlichen Grundlagen ist die Psychologie von vornherein interdisziplinär ausgerichtet
Wegen dieses umfassenden Blicks auf den Menschen kann die empirische Psychologie in ein besonderes Spannungsverhältnis zur Philosophischen Anthropologie geraten die ebenfalls einen umfassenden theoretischen Ansatz hat jedoch die empirischen Humanwissenschaften kaum noch zu integrieren vermag
Wichtige Themen der Psychologischen Anthropologie sind u a das Menschenbild die Persönlichkeitstheorien die Grundlagen von Motiven Emotionen in der Neurobiologie und Psychophysiologie die Beiträge der Kognitionswissenschaft Sozialpsychologie und Kulturpsychologie alle Bereiche der Angewandten Psychologie und so weiter
Auch Psychoanalyse und Psychosomatik galten als anthropologische Disziplinen
Pädagogische Anthropologie
Die pädagogische Anthropologie ist der Teilbereich der Pädagogik der sich mit dem Ertrag anthropologischer Fragen den Zugangsweisen und den Ergebnissen innerhalb der Pädagogik befasst
Grob lassen sich hier zwei Richtungen unterscheiden Die Realanthropologie widmet sich der empirischen Betrachtung der Wirklichkeit des Menschen unter dem Fokus der sich aus der Pädagogik ergibt
Die Sinnanthropologie fragt nach dem Sinn und den Zielen menschlichen Handelns die in den pädagogischen Kontext eingearbeitet werden
Die Sinnanthropologie weist so besondere Bezüge zur Bildungstheorie auf indem sie aus einem je spezifischen Menschenbild Bildungsansprüche ableitet
Sie weist innerhalb der verschiedenen Anthropologien eine besondere Nähe zur philosophischen und theologischen Anthropologie auf
Die Realanthropologie steht besonders der biologischen daneben auch der philosophischen Anthropologie nahe
Die Einteilung setzt sich fort in der Unterscheidung zwischen integrativen und philosophischen Ansätzen
Die integrativen Ansätze versuchen vor allem anthropologische Erkenntnisse verschiedener Teildisziplinen insbesondere der Biologie der Soziobiologie und so weiter für pädagogische Fragen nutzbar zu machen
Vertreter dieses Ansatzes sind unter anderem Heinrich Roth und Annette Scheunpflug
Der philosophische Ansatz hat sich in verschiedenen Richtungen ausdifferenziert
So besteht Otto Friedrich Bollnows Ansatz darin anthropologische Fragen beispielsweise nach dem Wesen des Menschen und seiner Bestimmung für pädagogische Zusammenhänge nutzbar zu machen
Ähnlich wie andere Autoren orientierte er sich in seinen Arbeiten aber auch an der Phänomenologie
Er versuchte also nicht aus der Philosophie oder etwa der Biologie ein Menschenbild zu gewinnen und es pädagogisch auszuwerten sondern widmete sich dem pädagogischen Handeln und darin auftretenden Phänomenen wie Krise oder Begegnung unmittelbar um sie als Bestimmungsgrößen des Menschen zu reflektieren
Der Mensch kommt bei diesen Untersuchungen im Hinblick auf Erziehung in drei Rollen vor als Erziehender als Zögling und als Erzieher
In der neueren pädagogischen Anthropologie wird zum einen der integrative Ansatz fortgeführt beispielsweise auch in der Betrachtung neuerer humanmedizinischer Ergebnisse für Pädagogik
Die philosophische Anthropologie wird heute verstärkt als historische pädagogische Anthropologie fortgesetzt indem reflektiert wird dass anthropologische Kenntnisse sowohl auf bestimmte Menschen in bestimmten Epochen bezogen als auch aus einer je spezifischen historischen Position heraus gewonnen werden und deshalb keine überzeitlich allgemeine Gültigkeit beanspruchen können
Kybernetische Anthropologie
Kybernetische Anthropologie bezeichnet den Versuch der begrifflichen Kopplung von Anthropologie und Kybernetik mit dem Vorhaben den Gegensatz zwischen Natur- und Geisteswissenschaften zu überwinden
Die Cyberanthropologie ist ein neueres Fachgebiet der Ethnologie Völkerkunde oder Sozialanthropologie und untersucht transnational zusammengesetzte Online-Gemeinschaften unter Berücksichtigung kybernetischer Perspektiven
Medizinische Anthropologie
Die im <num> Jahrhundert aufgekommene medizinische Anthropologie beschäftigt sich mit der Wechselwirkung von Kultur und Medizin
Anthropologie als Oberbegriff und Dachwissenschaft
DateiCleveland Museum of Art - damaged Thinkerjpg
Manchmal wird Anthropologie als Oberbegriff für mehrere der oben genannten Einzel- und Humanwissenschaften aufgefasst
Insbesondere in den USA gibt es dementsprechende Bestrebungen biologische Anthropologie Kulturanthropologie Ethnolinguistik und Archäologie unter einem Dach zu vereinen sog Vier-Felder-Anthropologie
Diese weit verbreitete Auffassung leitet sich von dem Tatbestand her dass Anthropologie -- im Gegensatz und oft in Konkurrenz zur Theologie -- Selbsterkenntnis des Menschen als Mensch ist gemäß der delphischen Maxime
Gnothi seauton
erkenne dich selbst
Die Systematische Anthropologie ein <num> veröffentlichtes Werk der deutschen Ethnologen Wolfgang Rudolph und Peter Tschohl bringt anthropologisch grundlegende Erkenntnisse in einen integrierten Zusammenhang
Mit Hilfe eines eigenen Begriffssystems wird ein gesamtanthropologisches Modell entwickelt das die Grenzen und Überschneidungen von Disziplinen wie Ethnologie Biologie Humangenetik Psychologie Soziologie Philosophie Geschichte theoretisch auflöst vergl zu diesem Ansatz Interdisziplinarität
Ziel der Untersuchung ist eine wissenschaftliche Theorie die dasjenige abdeckt was systematisch sinnvoll zu einem Mensch genannten Untersuchungsgegenstand gerechnet werden kann und die damit nicht von einer einzelnen Fachrichtung beherrscht wird
Die Untersuchung erschließt ausgehend von allgemeinen Bedingungen der Gesamtwirklichkeit die besonderen Bedingungen des biotischen und humanen Bereichs
Dafür wurde eine global orientierte Auswahl an Studien ausgewertet und die daraus entwickelte interdisziplinäre Systematik theoretisch konsequent ausformuliert
So lautet ein zentrales Untersuchungsergebnis in Kurzform Anthropologie ist zu explizieren als Theorie der Klassenexistenz Menschliche Existenz ME
Sie hat damit den vorverständlichen Gegenstandsbereich Mensch als Existenzklasse M aufzufassen und systematisch darzulegen Gegenstand ist die menschliche Existenz als empirisch beschreibbare Tatsache
Die Theorie transportierte einen damals fortschrittlichen humanen und weit gefassten Kulturbegriff
Wegen technokratisch anmutender Formulierung wurde sie aber nur in der ethnologisch und soziologisch orientierten Fachwelt rezipiert
Gerüst und Inhalt der Theorie müssten heute aktualisiert werden bieten jedoch eine Basis für Einzeluntersuchungen von beliebigen Ausschnitten des Gegenstandsbereichs Mensch
Die praktische Relevanz und damit die Rezeption der systematischen Anthropologie von Rudolph und Tschohl waren bereits bei Erscheinen des Werks <num> äußerst begrenzt
Kritiker wiesen darauf hin dass die positivistische Begriffssystematik völlig abgehoben von den aktuellen Diskussionen in den Sozialwissenschaften entwickelt worden war
Ihr theoretischer Wert lag in der Einübung einer hierarchisch vernetzten Nomenklatur die zwar als Ausgangspunkt für empirische Untersuchungen hätte dienen können wenn sie allgemeine Akzeptanz gefunden hätte aber über die Wirklichkeit menschlicher Lebensverhältnisse nicht viel mehr aussagte als ein systematisch geordneter Katalog der europäischen wissenschaftlichen Terminologie in den Humanwissenschaften
Ungeklärt blieb auch die Frage wie die Begriffssystematik von Rudolph und Tschohl in andere Sprach- und Kultursysteme hätte übertragen werden können
Fruchtbarere Ansätze wie das Konzept der reflexiven Anthropologie vergl dazu Pierre Bourdieu und Ethnomethodologie wurden dagegen aus dem anthropologischen Lehrbetrieb verdrängt
Die Basis-Theorie der Anthropologie
ist ebenfalls Orientierungswissen das Zusammenhänge zwischen den Disziplinen und Schulen der Humanwissenschaften aufzeigt
Ein Bezugsrahmen ergibt aus den vier Grundfragen der biologischen Forschung nach Nikolaas Tinbergen Verursachungen
Ursache-Wirkungs-Beziehungen bei den Funktionsabläufen Ontogenese Anpassungswert Phylogenese
Diese vier Aspekte sind jeweils auf verschiedenen Bezugsebenen zu berücksichtigen vgl Nicolai Hartmann beispielsweise Zelle Organ Individuum Gruppe
Dem tabellarischen Orientierungsrahmen aus Grundfragen und Bezugsebenen lassen sich alle anthropologischen Fragestellungen siehe PDF-Übersichtstabelle Absatz A ihre Ergebnisse siehe Tabelle Absatz B und Spezialgebiete zuordnen siehe Tabelle Absatz C er ist Grundlage für eine Strukturierung der Ergebnisse
Mit Hilfe der Basistheorie kann die anthropologische Forschung in Theorie und Empirie vorangetrieben und fundiertes sowie spekulatives Wissen besser auseinandergehalten werden betrifft z B
den Schulenstreit in der Psychotherapie
Siehe auch
Medienanthropologie
Literatur
Allgemein
Axel W Bauer Was ist der Mensch
Antwortversuche der medizinischen Anthropologie
In Fachprosaforschung - Grenzüberschreitungen <num><num> <num><num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
Der blaue reiter
Journal für Philosophie
Themenheft Grenzpunkt Mensch
Nr <num> <num>
Verlag der blaue Reiter ISBN <num>-<num>-<num>-<num>-<num>
Joachim Bauer Prinzip Menschlichkeit
Warum wir von Natur aus kooperieren
Hoffmann und Campe Hamburg <num> ISBN <num>-<num>-<num>-X
Eike Bohlken Christian Thies Hrsg Handbuch Anthropologie
Der Mensch zwischen Natur Kultur und Technik
Metzler Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Martin Buber Ich und Du Insel Leipzig <num> Reclam Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Zeno Bucher Die Abstammung des Menschen als naturphilosophisches Problem Koenigshausen
Neumann Würzburg <num> ISBN <num>-<num>-<num>-<num>
Werner Fuchs u a Hrsg Lexikon zur Soziologie
Westdeutscher Verlag Opladen <num> <num> ISBN <num>-<num>-<num>-<num>
Hans-Georg Gadamer Paul Vogler Hrsg Neue Anthropologie Thieme Stuttgart und dtv München <num>-<num> Band <num> und <num> Biologische Anthropologie Band <num> Sozialanthropologie Band <num> Kulturanthropologie Band <num> Psychologische Anthropologie Band <num> und <num> Philosophische Anthropologie
Gisela Grupe u a Anthropologie
Ein einführendes Lehrbuch
Springer Berlin <num> ISBN <num>-<num>-<num>-<num>
Marvin Harris Menschen DTV München <num> ISBN <num>-<num>-<num>-<num>
Winfried Henke Hartmut Rothe Menschwerdung Fischer Frankfurt <num> ISBN <num>-<num>-<num>-<num>
Uwe Hoßfeld Geschichte der biologischen Anthropologie in Deutschland Von den Anfängen bis in die Nachkriegszeit
Steiner Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Holger Jebens Karl-Heinz Kohl Hrsg The End of Anthropology Sean Kingston Wantage <num> ISBN <num>-<num>-<num>-<num>-<num> englisch deutsche Professoren ausführliche Fachbesprechung doi<num><num><num>
Rainer Knußmann Hrsg Anthropologie Handbuch der vergleichenden Biologie des Menschen
Bd <num>I <num>II
Fischer Stuttgart <num><num> ISBN <num>-<num>-<num>-<num>
Marc Rölli Kritik der anthropologischen Vernunft Matthes
Seitz Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
Max Scheler Die Stellung des Menschen im Kosmos In Max Scheler Gesammelte Werke Band <num> Francke Bern <num> ISBN <num>-<num>-<num>-<num>
Friedemann Schrenk Timothy G Bromage Henrik Kaessmann Die Frühzeit des Menschen
Zurück zu den Wurzeln
In Biologie in unserer Zeit Nr <num> Weinheim <num>
S <num>-<num>
Thomas Suddendorf Der Unterschied
Was den Mensch zum Menschen macht
Berlin Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>
Ferdinand Tönnies Schriften und Rezensionen zur Anthropologie hg von Rolf Fechner Profil München und Wien <num> ISBN <num>-<num>-<num>-<num>-<num>
Christoph Wulf Anthropologie
Geschichte Kultur Philosophie
Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num>
Geschichte
Wilhelm E Mühlmann Geschichte der Anthropologie
<num> Auflage
Aula Wiesbaden <num> ISBN <num>-<num>-<num>-<num>
Christoph Wulf Hrsg Vom Menschen
Handbuch Historische Anthropologie
Beltz WeinheimBasel <num>
Glenn H Penny Matti Bunzl Hrsg Worldly Provincialism
German Anthropology in the Age of Empire
Ann Arbor <num>
Bernhard Rathmayr Die Frage nach den Menschen
Eine historische Anthropologie der Anthropologien
Barbara Budrich Opladen <num>
Medizinische Anthropologie
Eduard Seidler Hrsg Medizinische Anthropologie
Beiträge für eine Theoretische Pathologie
BerlinHeidelbergNew YorkTokyo <num>
Veröffentlichungen aus der Forschungsstelle für Theoretische Pathologie der Heidelberger Akademie der Wissenschaften
Vergleichende Anthropologie
Rainer Knußmann Vergleichende Biologie des Menschen
Lehrbuch der Anthropologie und Humangenetik
Fischer Stuttgart <num> <num> ISBN <num>-<num>-<num>-X
Pädagogische Anthropologie
Herbert Becker Hrsg Anthropologie und Pädagogik Klinkhardt Bad Heilbrunn <num> ISBN <num>-<num>-<num>-<num>
D Kamper Ch Wulf Hrsg Anthropologie nach dem Tode des Menschen Suhrkamp Frankfurt <num> ISBN <num>-<num>-<num>-<num>
Norbert Kühne Aspekte und Probleme früher Entwicklung und Erziehung In
Unterrichtsmaterialien Pädagogik-Psychologie
Nr <num> Stark VerlagMediengruppe Pearson Hallbergmoos <num>-<num>
Johanna Uher Hrsg Pädagogische Anthropologie und Evolution Erlangen <num> ISBN <num>-<num>-<num>-<num>
Christoph Wulf Einführung in die pädagogische Anthropologie Beltz WeinheimBasel <num> ISBN <num>-<num>-<num>-<num>
Spezielle Themen
Manfred Engel Romantische Anthropologie
Skizze eines Forschungsprojekts
In Historische Anthropologie Band <num> <num> S <num>-<num>
Michael Post Entwurf der Grundlegung der fundamentalontologischen Anthropologie und natürlichen Theologie Neuss <num> ISBN <num>-<num>-<num>-<num>-<num>
Bernhard Verbeek Die Anthropologie der Umweltzerstörung die Evolution und der Schatten der Zukunft Primus Darmstadt <num> ISBN <num>-<num>-<num>-<num>
Rüdiger Zymner Manfred Engel Hrsg Anthropologie der Literatur
Poetogene Strukturen und ästhetisch-soziale Handlungsfelder
Poetogenesis
Studien und Texte zur empirischen Anthropologie der Literatur
Mentis Paderborn <num> ISBN <num>-<num>-<num>-<num>
Weblinks
Gesellschaft für Anthropologie
Einzelnachweise
Axel W Bauer Bemerkungen zur Verwendung des Terminus Anthropologie in der Medizin der Neuzeit <num>-<num> Jahrhundert In Eduard Seidler Hrsg Medizinische Anthropologie <num> S <num>-<num> Seite der Arbeitsstelle Kleine Fächer zur Anthropologie abgerufen am <num> April <num> Axel W Bauer Was ist der Mensch Antwortversuche der medizinischen Anthropologie In Fachprosaforschung - Grenzüberschreitungen <num><num> <num><num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num> insbesondere S <num>-<num> hier S <num> f Christian Friedrich Nasse Hrsg Zeitschrift für die Anthropologie Cnobloch Leipzig <num>-<num> vorher Friedrich Nasse Hrsg Zeitschrift für psychische Ärzte Band <num>-<num> Leipzig <num>-<num> derselbe Hrsg Zeitschrift für psychische Ärzte mit besonderer Berücksichtigung des Magnetismus Leipzig <num>-<num> Nachruf Martin Rudolf Jahrbuch <num> Mollier - badwde Gerfried Ziegelmayer <num> Jahre Anthropologie in München In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num>-<num> Wulf Kamper Anthropologie In Heinz-Elmar Tenorth Rudulf Tippelt Hrsg BELTZ Lexikon Pädagogik Beltz WeinheimBasel <num> S <num>-<num> Axel Honneth Hans Joas Soziales Handeln und menschliche Natur Anthropologische Grundlagen der Sozialwissenschaften Campus Frankfurt am Main <num> S
I L Horowitz The life and death of project Camelot In American Psychologist Band <num> Nr <num> <num> S <num>-<num> doi<num>h<num> Wolf Lepenies Soziologische Anthropologie Materialien München Hanser <num> S <num> Gesa Lindemann Das Soziale von seinen Grenzen her denken Velbrück Weilerswist <num> S
Axel W Bauer Was ist der Mensch Antwortversuche der medizinischen Anthropologie <num><num> <num> S <num> f Erich Weber Pädagogische Anthropologie Donauwörth Ludwig Auer Verlag <num> Aufl <num> S <num> f Christoph Wulf Zur Einleitung Grundzüge einer historisch-pädagogischen Anthropologie In Derselbe Hrsg Einführung in die pädagogische Anthropologie Beltz Weinheim u a <num> S <num> Winfried Effelsberg Interkulturelle Konflikte in der Medizin Medizinanthropologische Überlegungen In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num> zitiert Axel W Bauer Was ist der Mensch Antwortversuche der medizinischen Anthropologie In Fachprosaforschung - Grenzüberschreitungen <num><num> <num><num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num> insbesondere S <num>-<num> Übersicht <num> aus Gerhard Medicus Was uns Menschen verbindet Humanethologische Angebote zur Verständigung zwischen Leib- und Seelenwissenschaften <num> Auflage VWB Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
DateiNapoli BW <num>-<num>-<num> <num>-<num>-<num>jpg Alexander der Große
bzw Alexander III
von Makedonien
<num> Juli <num> v Chr in Pella
<num> Juni <num> v Chr in Babylon war von <num> v Chr
bis zu seinem Tod König von Makedonien und Hegemon des Korinthischen Bundes
Alexander dehnte die Grenzen des Reiches das sein Vater Philipp II aus dem vormals eher unbedeutenden Kleinstaat Makedonien sowie mehreren griechischen Poleis errichtet hatte durch den sogenannten Alexanderzug und die Eroberung des Achämenidenreichs bis an den indischen Subkontinent aus
Nach seinem Einmarsch in Ägypten wurde er dort als Pharao begrüßt
Nicht zuletzt aufgrund seiner großen militärischen Erfolge wurde das Leben Alexanders ein beliebtes Motiv in Literatur und Kunst während Alexanders Beurteilung in der modernen Forschung wie auch schon in der Antike zwiespältig ausfällt
Mit seinem Regierungsantritt begann das Zeitalter des Hellenismus in dem sich die griechische Kultur über weite Teile der damals bekannten Welt ausbreitete
Die kulturellen Prägungen durch die Hellenisierung überstanden den politischen Zusammenbruch des Alexanderreichs und seiner Nachfolgestaaten und wirkten noch jahrhundertelang in Rom und Byzanz fort
Leben
Frühe Jahre <num>-<num> v Chr
DateiAlexander amp Bucephalus by John SteellJPG
Alexander wurde im Jahre <num> v Chr als Sohn König Philipps II von Makedonien und der Königin Olympias geboren
Viele Einzelheiten seiner Biografie vor allem aus der Kindheit wurden später legendenhaft ausgeschmückt oder frei erfunden
So berichtet der Geschichtsschreiber Plutarch dass Alexander ohne Zweifel seinen Stammbaum väterlicherseits auf Herakles und Karanos den ersten König der Makedonen zurückverfolgen konnte wodurch Plutarch zugleich die Abstammung Alexanders vom Göttervater Zeus implizit hervorhebt Ebenso berichtet er dass Olympias und Philipp Träume gehabt hätten die ihnen der Seher Aristander so deutete dass ihnen die Geburt eines Löwen bevorstehe Olympias nahm für sich in Anspruch in direkter Linie von dem griechischen Heros Achilleus und Aiakos einem weiteren Sohn des Zeus abzustammen Nach einer vermutlich ebenfalls legendären Erzählung Plutarchs soll Alexander in jungen Jahren sein Pferd Bukephalos das ihn später bis nach Indien begleitete gezähmt haben nachdem es zuvor niemandem gelungen war es zu bändigen
Alexander erkannte was den Fehlschlägen der anderen zugrunde lag Das Pferd schien den eigenen Schatten zu scheuen
Daraufhin habe Philipp zu ihm gesagt
Geh mein Sohn suche dir ein eigenes Königreich das deiner würdig ist
Makedonien ist nicht groß genug für dich
Abgesehen von den Legenden ist wenig über Alexanders Kindheit bekannt
Makedonien war ein Land das im Norden des Kulturraums des antiken Griechenlands lag
Es wurde von vielen Griechen als barbarisch unzivilisiert angesehen obwohl das Königsgeschlecht als griechisch anerkannt wurde
In der Antike gab es ohnehin keinen einheitlichen Staat Griechenland sondern eine durch gemeinsame Kultur Religion und Sprache verbundene Gemeinschaft der griechischen Klein- und Stadtstaaten
Im frühen <num> Jahrhundert v Chr wurden erstmals Makedonen zu den Olympischen Spielen zugelassen nachdem König Alexander I eine Abstammung aus dem griechischen Argos in Anspruch genommen hatte Noch heute birgt die Diskussion um die ethnische Zugehörigkeit politischen Konfliktstoff
Aus den verfügbaren Quellen ist ersichtlich dass das Makedonische von dem nur wenige Wörter überliefert sind für die Griechen wie eine fremde Sprache klang Ob das Makedonische ein griechischer Dialekt oder eine mit dem Griechischen verwandte eigenständige Sprache war ist immer noch umstritten
Kulturell und gesellschaftlich unterschieden sich die Makedonen recht deutlich von den Griechen keine städtische Kultur als Binnenreich kaum Kontakte zum mediterranen Kulturraum Königtum was in Griechenland nicht die Regel war
Auf viele Griechen wird die makedonische Gesellschaft archaisch gewirkt haben Erst im <num> Jahrhundert v Chr
verstärkte sich der griechische kulturelle Einfluss in der makedonischen Oberschicht
DateiKarte Makedonien <num> vC-desvg
Alexanders Vater Philipp II
hatte das bisher eher unbedeutende Makedonien das vor ihm Streitobjekt der Adelsfamilien des Hoch- und des Tieflands gewesen war zur stärksten Militärmacht der damaligen Zeit gemacht
Er hatte Thessalien und Thrakien erobert und alle griechischen Stadtstaaten mit Ausnahme Spartas in ein Bündnis unter seiner Führung gezwungen Korinthischer Bund
Schon an diesen Kriegszügen war Alexander beteiligt etwa in der Schlacht von Chaironeia <num> v Chr in der die griechischen Städte unter Führung Athens unterworfen wurden
Die makedonische Phalanx erwies sich dabei als ein wichtiges Element für den militärischen Erfolg zentral war jedoch die Rolle der Hetairenreiterei
Alexanders spätere Erfolge gehen zweifellos zu einem bedeutenden Teil auf die Militärreformen seines Vaters zurück
Philipp umgab sich außerdem mit sehr fähigen Offizieren wie etwa Parmenion die auch einen großen Anteil an Alexanders späteren Siegen hatten
Philipp holte den griechischen Philosophen Aristoteles in die makedonische Hauptstadt Pella und beauftragte ihn Alexander in Philosophie Kunst und Mathematik zu unterrichten
Der Einfluss des Aristoteles sollte wohl nicht zu hoch veranschlagt werden doch sicher war Alexander sehr gebildet seine Abschrift der
Ilias
hütete er wie einen Schatz und er brachte der griechischen Kultur große Bewunderung entgegen
Das Verhältnis zwischen Vater und Sohn war keineswegs frei von Konflikten gerade in Hinsicht auf die Liebschaften des Vaters
Philipp hatte <num> v Chr Kleopatra die Nichte seines Generals Attalos als Nebenfrau geheiratet
Während eines Banketts soll Attalos Öl ins Feuer gegossen und gesagt haben er hoffe dass Philipp nun einen legitimen Erben erhalten würde
Alexander sei daraufhin wutentbrannt aufgefahren und habe Attalos angeschrien
Soll das heißen ich sei ein Bastard
Alexander warf einen Becher nach Attalos und wollte auf ihn losgehen
Auch Philipp erhob sich und zog sein Schwert jedoch nicht um Alexander in Schutz zu nehmen sondern um Attalos zu helfen
Da aber Philipp bereits betrunken war stolperte er und fiel hin
Alexander soll ihn höhnisch angeblickt haben und sich den versammelten Makedonen zugewandt haben
Seht ihn euch an meine Herren
Dieser Mann will euch von Europa nach Asien führen aber er scheitert schon bei dem Versuch von einem Liegebett zum nächsten zu gehen
Plutarch Alexander <num>
Alexander befürchtete nun offenbar von der Thronfolge ausgeschlossen zu werden
Schließlich floh er mit seiner Mutter über Epeiros nach Illyrien
Nach einem halben Jahr kehrte er nach Pella zurück doch seine Thronfolge blieb weiterhin unsicher
Philipp wurde im Sommer <num> v Chr in der alten Hauptstadt Aigai auch bekannt als Vergina während der Hochzeit seiner Tochter Kleopatra mit dem König Alexander von Epeiros von dem Leibgardisten Pausanias ermordet Das Motiv des Täters scheint offensichtlich Pausanias war ein Vertrauter Philipps gewesen und war von Attalos beleidigt worden dabei fühlte er sich von Philipp ungerecht behandelt
Es gab aber bald darauf Gerüchte wonach Alexander an der Tat beteiligt gewesen war
Die Mutmaßungen über die Hintergründe des Mordes und über eine Verwicklung von Olympias und Alexander sind weitgehend spekulativ auch wenn eine Mitwisserschaft nicht ausgeschlossen werden kann
Regierungsübernahme und Sicherung der Macht <num>-<num> v Chr
DateiAlexanderTheGreat Bust Transparentpng
Im Jahre <num> v Chr folgte der zwanzigjährige Alexander seinem Vater auf den Thron Dass es keinen nennenswerten Widerstand gab ist offenbar Antipater zu verdanken der das Heer dazu bewog Alexander als König anzuerkennen
Schon in den ersten Tagen ließ er Mitglieder des Hofstaats exekutieren die das Gerücht gestreut hatten Alexander habe etwas mit der Ermordung seines Vaters zu tun gehabt
Als nächstes wandte er sich seinem Erzfeind Attalos zu der sich auf der Flucht befand jedoch von seinem Schwiegervater Parmenion getötet wurde
Sowohl Antipater als auch Parmenion standen deswegen lange in Alexanders besonderer Gunst und profitierten nicht unerheblich davon Antipater blieb während des Asienfeldzugs als Reichsverweser in Makedonien während Parmenion sich seine Unterstützung mit großem Einfluss im Heer vergelten ließ
Noch <num> ließ sich Alexander in Korinth die Gefolgschaft der griechischen Städte versichern
Die Völker in Thrakien und Illyrien versuchten jedoch die Situation zu nutzen und die makedonische Herrschaft abzuwerfen
Alexander zog im Frühjahr <num> v Chr
mit <num> Mann nach Norden ins heutige Bulgarien und Rumänien überquerte die Donau und warf die thrakische Revolte nieder Anschließend verfuhr er ebenso mit den Illyrern siehe auch Balkanfeldzug Alexanders des Großen
Während Alexander im Norden kämpfte beschlossen die Griechen im Süden dass dies der Zeitpunkt sei sich von Makedonien zu befreien
Ihr Wortführer war Demosthenes der die Griechen davon zu überzeugen versuchte dass Alexander in Illyrien gefallen und Makedonien herrscherlos sei
Als erste erhoben sich die Einwohner Thebens und vertrieben die makedonischen Besatzungssoldaten aus der Stadt
Alexander reagierte augenblicklich und marschierte direkt von seinem Illyrienfeldzug südwärts nach Theben
Die Phalanx seines Generals Perdikkas eroberte die Stadt wo Alexander zur Bestrafung sämtliche Gebäude mit Ausnahme der Tempel und des Wohnhauses des Dichters Pindar zerstören ließ
Sechstausend Einwohner wurden getötet die übrigen <num> wurden in die Sklaverei verkauft
Die Stadt Theben existierte nicht mehr und sollte erst zwanzig Jahre später wieder aufgebaut werden aber nie mehr zur alten Bedeutung zurückfinden
Abgeschreckt von Alexanders Strafgericht brachen die anderen Städte Griechenlands ihre Revolte ab und ergaben sich
Von den Korinthern ließ sich Alexander von neuem die Gefolgschaft versichern und verschonte sie daraufhin da er sie als Verbündete in seinem Persienfeldzug brauchte
Beginn des Persienfeldzugs <num>-<num> v Chr
DateiMakedonischesReichjpg
Das Perserreich war zu Alexanders Zeit die größte Territorialmacht der Erde
Die Perserkönige hatten in den zurückliegenden Jahrhunderten die Levante Mesopotamien Ägypten und Kleinasien erobert und zwischen <num> und <num> v Chr mehrere Versuche unternommen auch Griechenland zu unterwerfen siehe Perserkriege
Aus Sicht von Griechen wie Isokrates ebenso wie der älteren Forschung war das Reich aber um <num> v Chr geschwächt und hatte seinen Zenit überschritten
In der neueren Forschung wird dies allerdings bestritten so war den Persern wenige Jahre vor dem Alexanderzug die Rückeroberung des zwischenzeitlich abgefallenen Ägypten gelungen
Ob Persien für die Makedonen eine leichte Beute war ist daher umstritten
Als sich Alexander <num> v Chr
dem Perserreich zuwandte wurde dies von Dareios III aus dem Haus der Achämeniden beherrscht
Schon Alexanders Vater Philipp hatte Pläne für einen Angriff auf die Perser geschmiedet angeblich um Rache für die Invasion Griechenlands rund <num> Jahre zuvor zu nehmen wobei es sich dabei eher um Propaganda handelte und machtpolitische Gründe den Ausschlag gegeben haben dürften Eine Armee unter Parmenion einem der fähigsten makedonischen Generäle war bereits über den Hellespont nach Asien gegangen wurde von den Persern aber zurückgeschlagen
Alexander überschritt den Hellespont im Mai <num> v Chr mit einer Armee aus etwa <num> Makedonen und Griechen um in die Kämpfe einzugreifen während rund <num> Makedonen unter Antipatros Makedonien und Griechenland sichern sollten
In der Schlacht am Granikos Mai <num> v Chr kam es zur ersten Begegnung mit den persischen Streitkräften unter der Führung eines Kriegsrates der Satrapen
Der für die Perser kämpfende Grieche Memnon von Rhodos führte <num> griechische Söldner doch konnte er sich im Kriegsrat mit einer defensiven Taktik nicht durchsetzen
Alexander errang auch aufgrund einer ungünstigen Aufstellung der Perser einen deutlichen Sieg
Memnon konnte mit einem Teil der Söldner entkommen
Dadurch war die Befreiung der Städte Ioniens möglich geworden die Alexander als Motiv für seinen Feldzug genannt hatte
Nach dem Sieg ernannte Alexander eigene Statthalter für die bisherigen Satrapien und übernahm damit die politischen und wirtschaftlichen Strukturen der persischen Verwaltung Kleinasiens
In Lydien zog Alexander kampflos in Sardes ein
Er weihte den örtlichen Tempel dem Zeus und nutzte die Reichtümer der Stadt um seine Männer zu bezahlen
Dann zog er weiter nach Ephesos
Dort war kurz zuvor Memnon mit den Resten der Söldner vom Granikos hindurchgezogen und hatte Unruhen unter den städtischen Parteien entfacht
Alexander ließ die alten Institutionen wiederherstellen und regelte die Befugnisse des Tempels der Artemis
Nach einer Ruhe- und Planungspause brach der König mit dem Gros des Heeres nach Milet auf der größten Stadt an der Westküste Kleinasiens
Der dortige Satrap kapitulierte als Einziger nicht da ihm die Ankunft einer persischen Hilfsflotte von <num> Schiffen versprochen worden war
Da auch Alexander von dieser Flotte gehört hatte wies er Nikanor einen Bruder Parmenions an mit <num> Schiffen die Einfahrt zur Bucht von Milet zu versperren
Anschließend gelang ihm die Einnahme der Stadt
Belagerung von Milet
Die Perser die immer noch unter dem Befehl Memnons standen allerdings hatten Unstimmigkeiten im persischen Oberkommando einen effektiven Widerstand erschwert sammelten sich nun in Halikarnassos der Hauptstadt Kariens und bereiteten die Stadt auf eine Belagerung vor
Die Kämpfe waren für Alexander sehr verlustreich
Zwischenzeitlich handelte er einen Waffenstillstand aus um die makedonischen Gefallenen zu bergen - etwas was er nie zuvor getan hatte und nie wieder tun sollte
Als er letztlich die Mauern durchbrach entkam Memnon mit dem Großteil seiner Soldaten auf Schiffen aus der fallenden Stadt
Belagerung von Halikarnassos
Indem Alexander der karischen Satrapentochter Ada die Herrschaft über Halikarnassos versprach sicherte er sich das Bündnis mit dem Volk Kariens
Manche Quellen sprechen davon dass Ada Alexander adoptierte
Hier zeigte Alexander erstmals seine Taktik Großzügigkeit gegenüber besiegten Völkern walten zu lassen um sie nicht gegen die Makedonen aufzubringen
Das ursprüngliche Ziel des Persienfeldzugs die Eroberung der Westküste Kleinasiens war hiermit erreicht
Dennoch beschloss Alexander die Expedition fortzusetzen
Entlang der Küsten Lykiens und Pamphyliens traf die makedonisch-griechische Streitmacht auf keinerlei nennenswerten Widerstand
Eine Stadt nach der anderen ergab sich kampflos
Alexander ernannte seinen Freund Nearchos zum Statthalter von Lykien und Pamphylien
Im Winter <num><num> v Chr
eroberte Alexander das anatolische Binnenland
Er stieß vom Süden vor sein General Parmenion von Sardes im Westen
Die beiden Armeen trafen sich in Gordion der Hauptstadt der persischen Satrapie Phrygien
Hier soll Alexander der Große der Legende nach den Gordischen Knoten mit seinem Schwert durchschlagen haben über den ein Orakel prophezeit hatte nur derjenige der diesen Knoten löse könne die Herrschaft über Asien erringen
Es gibt aber auch die Version dass Alexander mit der Breitseite des Schwertes auf die Wagendeichsel schlug so dass der Druck den Knoten auseinanderriss
Die Makedonen blieben einige Zeit in Gordion um Nachschub an Männern und die Einfuhr der Ernte abzuwarten
Während dieser Zeit starb Memnon der Befehlshaber der persischen Armee im August <num> v Chr
an einer Krankheit
Zu seinem Nachfolger wurde Pharnabazos ernannt und da sich die Perser bereits wieder formierten brach Alexander erneut auf
In Gordion ließ er seinen General Antigonos als Statthalter Phrygiens zurück und übertrug ihm die Aufgabe den Norden Anatoliens zu unterwerfen und die Nachschubwege zu sichern
Durch Kappadokien marschierte Alexanders Heer nach Kilikien
Dort nahm er nach einem kurzen Gefecht die Hauptstadt Tarsos ein wo er bis zum Oktober blieb
Schlacht bei Issos <num> v Chr
DateiAlexander Sarcophagusjpg
In Tarsos erfuhr Alexander dass Dareios III die Bedrohung endlich ernst genug nahm um selbst ein Heer aus dem persischen Kernland nach Westen zu führen
Plutarch zufolge war dieses persische Heer <num> Mann stark - eine Angabe die sicherlich maßlos übertrieben ist Der berühmte Althistoriker Karl Julius Beloch der den Quellen immer sehr skeptisch gegenüberstand schätzte die tatsächliche Zahl der Perser auf höchstens <num> die Stärke des makedonischen Heeres dagegen auf ca <num> - <num> Mann
Dareios gelang es Alexanders Armee im Norden zu umgehen und Issos zu besetzen wodurch er die Nachschubwege blockierte
Auch ließ Dareios die in Issos zurückgebliebenen Verwundeten töten
In der Schlacht bei Issos trafen die Armeen im Kampf aufeinander bis Dareios aufgrund der großen Verluste der Perser vom Schlachtfeld floh
Die Makedonen beklagten <num> Tote und <num> Verwundete
Unbekannt sind die persischen Verluste sie dürften aber weit höher gewesen sein
Insgesamt hatte die persische Führung während der Schlacht mehrere Fehler begangen angefangen bei der Aufstellung - man hatte auf die Umgruppierungen Alexanders nicht reagiert
Auch als Symbol kam der Schlacht große Bedeutung zu Dareios hatte sich als seinem Gegner nicht gewachsen gezeigt
Zur Sicherung des Lagers der Perser sandte Alexander seinen General Parmenion nach Damaskus
Neben dem reichen Kriegsschatz befanden sich hier auch mehrere Mitglieder der königlichen Familie Zu den Gefangenen die in die Hände der Makedonen fielen gehörten die Mutter des Dareios seine Frau Stateira ein fünfjähriger Sohn und zwei Töchter
Alexander behandelte sie mit Respekt
Außerdem wurde Barsine gefangen genommen die Witwe des Memnon
Es kam zu einer Liebesaffäre zwischen Alexander und Barsine aus der später ein Sohn hervorgehen sollte der Herakles genannt wurde
Schon bald bat Dareios Alexander um den Abschluss eines Freundschaftsvertrags und die Freilassung seiner Familie
Alexander antwortete Dareios solle zu ihm kommen und Alexander als König von Asien anerkennen dann würde seine Bitte erfüllt andernfalls solle er sich auf den Kampf vorbereiten
Nach der Schlacht gründete Alexander die erste Stadt in Asien die er nach sich benannte Alexandretta das heutige İskenderun
Hier siedelte er die <num> Verwundeten der Schlacht an
Lage nach der Schlacht von Issos
Der Ausgang der Schlacht überraschte die antike Welt
Die Erwartungen der Herrscher von Karthago in Italien Sizilien von Sparta bis Zypern die Kalkulationen der Handelsherren im westlichen Mittelmeerraum in Athen auf Delos und in Phönizien erfüllten sich nicht
statt der erwarteten Siegesnachricht aus Kilikien kam die von der gänzlichen Niederlage des Großkönigs von der völligen Vernichtung des Perserheeres
Auch die Delegationen aus Athen Sparta und Theben die im Hauptquartier des Großkönigs in Damaskus den Verlauf der Feldzüge verfolgten wurden von Alexanders Feldherrn Parmenion gefangen gesetzt
Alexander selbst widerstand der Versuchung den Krieg durch einen Marsch nach Babylon rasch zu entscheiden doch hatte er es nicht einfach seine Befehlshaber und Gefährten von einer Defensivstrategie zu überzeugen
Nach wie vor beherrschte die persische Flotte das östliche Mittelmeer - sie verfügte zwar über keine Häfen mehr in Kleinasien jedoch nach wie vor in Phönizien
Durch die Münzgeldtribute hier waren die finanziellen Mittel der Perser noch wenig eingeschränkt und auch Ägypten stand ihnen noch als logistische und militärische Basis zur Verfügung
Die kommenden Winterstürme ließen zwar keine Flottenunternehmungen mehr erwarten und damit auch keine Gefahr einer raschen Erhebung der Griechen gegen Makedonien - insbesondere des Spartanerkönigs Agis IV - doch kam es nun auch auf das Verhalten der phönizischen Geschwader an die einen Großteil der persischen Flotte stellten
Zwar verblieben sie in dieser Jahreszeit noch in der Fremde doch nahm Alexander an dass er diese Kontingente durch eine sofortige Besetzung ihrer Heimatstädte zumindest neutralisieren könne
Auch die kyprischen Könige glaubten für ihre Insel fürchten zu müssen sobald die phönikische Küste in Alexanders Gewalt war Nach einer Besetzung Phöniziens und Ägyptens könne dann ein Feldzug nach Asien von einer gesicherten Basis aus geführt werden obwohl die Perser natürlich auch Zeit für neue Rüstungen gewannen
Die Versammlung stimmte Alexanders Plan zu
Die Schlacht von Issos hatte noch keine grundsätzliche Entscheidung gebracht Entgegen den Erwartungen wurde das makedonische Heer nicht vernichtet und Alexander besaß mit der persischen Kriegskasse in Damaskus die Mittel zur Fortführung des Feldzuges
Eine Entscheidung des Krieges war dadurch nicht bewirkt worden
Eingezogen wurden in Damaskus <num> Talente in Münzgeld und <num> Pfund Silber die ausreichten alle Soldschulden der Armee und Sold für etwa sechs weitere Monate zu bezahlen
Belagerung von Tyros und das zweite Angebot des Dareios <num> v Chr
Während die Städte in der nördlichen Hälfte Phöniziens - Marathos Byblos Arados Tripolis und Sidon - sich dem Makedonen bereitwillig ergaben war die dominierende Handelsmetropole Tyros allenfalls zu einem Vergleich bereit
Sie baute dabei auf ihre Insellage knapp vor der Küste auf ihre vor Ort verfügbare eigene Flotte und die Unterstützung ihrer mächtigen Tochterstadt Karthago
Nachdem Alexander der Zutritt zur Stadt verwehrt worden war - sein Prüfstein war das Verlangen nach einem Opfer im Tempel des Stadtgottes Melkart des tyrischen Herakles - brach der König die Verhandlungen ab
Er beschloss Tyros um jeden Preis einzunehmen denn er plante schon den Vorstoß nach Ägypten und wollte eine feindliche Stadt die sowohl mit den Persern als auch mit rebellischen Kräften in Griechenland kooperieren würde nicht unbezwungen in seinem Rücken lassen
Eine von Arrian überlieferte angebliche Rede Alexanders vor seinen Offizieren in der die strategischen Überlegungen erläutert werden ist allerdings eine literarische Fiktion die auf der Kenntnis des späteren Verlaufs des Feldzugs beruht Vor dem Beginn der Belagerung bot Alexander den Tyrern Schonung an falls sie kapitulierten
Sie töteten jedoch seine Unterhändler und warfen die Leichen von den Stadtmauern
Damit war der Weg zu einer Einigung endgültig versperrt
Ohne Flotte blieb nur die Möglichkeit eines Dammbaues durch das zumeist seichte Gewässer das die vorgelagerte Inselstadt von der Küste trennte und der Versuch mit Belagerungsmaschinen Teile der Mauern zu zerstören
Die Finanzierung dieser aufwendigen Methode die eine entwickelte Technik und die dafür entsprechenden Materialien und Fachkräfte erforderte konnte Alexander durch die Beute aus dem persischen Hauptquartier in Damaskus bewerkstelligen
Ein erster Dammbau wurde von den Tyrern erfolgreich bekämpft es gelang ihnen bei stürmischem Wetter mit einem Brander die zwei Belagerungstürme an der Spitze des Dammes zu entzünden und durch Begleitschiffe mit Geschützen jeden Löschversuch zu vereiteln
Der Sturm riss zudem den vorderen Teil des Dammes weg
Der Vorfall löste im makedonischen Heer Entmutigung aus zumal wieder Gesandte des Dareios eintrafen und ein neues Friedensangebot des Großkönigs überbrachten das Alexander den Besitz des Landes diesseits des Euphrat <num> Talente Lösegeld für seine gefangene Gemahlin und die Hand seiner Tochter anbot
In diese Zeit fiel auch die - vermutlich von Kallisthenes übermittelte - Reaktion des Befehlshabers Parmenion Wäre er Alexander so würde er akzeptieren
Alexander entgegnete das würde er auch tun wenn er Parmenion wäre
Alexander ließ Dareios mitteilen er Alexander werde sich nehmen was er wolle wenn Dareios etwas von ihm erbitten wolle solle er zu ihm kommen
Der Damm wurde in größerer Breite wiederhergestellt und neue Türme gebaut In der Zwischenzeit - nach den Winterstürmen - trafen auch die phönizischen Flottenkontingente und die Geschwader der Könige von Zypern in ihren Heimathäfen ein und standen nun Alexander zur Verfügung insgesamt <num> Schiffe darunter auch Vier- und Fünfruderer
Diese Bundesgenossenschaft lag auch in der Feindschaft der kleineren Städte Phöniziens gegen Tyros begründet Die Metropole hatte zwanzig Jahre zuvor zwar einen Aufstand unter Führung von Sidon gegen die Perser befürwortet und Hilfe zugesagt dann jedoch den Verlauf der Auseinandersetzungen abgewartet und war von den Persern für diese Haltung belohnt worden
Nach der Niederschlagung der Erhebung und der Zerstörung von Sidon errang Tyros die Vorherrschaft unter den phönizischen Handelsstädten
Während die neu gewonnene Flotte ausgerüstet wurde unternahm Alexander eine Expedition durch das küstennahe Gebirge des Antilibanon um die Festungen von Gebirgsstämmen zu bezwingen den Nachschub Holz für den Maschinenbau und die Verbindung nach Damaskus zu sichern
Die Karthager konnten den Tyrern nicht helfen da sie sich im Krieg mit Syrakus befanden Nach weiteren wechselvollen Kämpfen um die Stadtmauern und zur See die die Tyrer immer mehr Schiffe kosteten war die Zeit zum Sturmangriff reif
Alexander beschloss einen kombinierten Land- und Seeangriff
Auf der durch den Damm erreichbaren Seite gelang es Breschen in die Mauern zu schlagen und ein Landeunternehmen durchzuführen die phönizischen Schiffe sprengten die Sperrketten im Südhafen und bohrten die dort liegenden Schiffe in den Grund die zyprische Flotte verfuhr ebenso im Nordhafen - dort gelang es den Truppen zusätzlich in die Stadt einzudringen
Die überlieferte Zahl von <num> Gefallenen der Stadt soll sich auf die gesamte Belagerungszeit beziehen Ob die anschließende angebliche Kreuzigung von <num> Kämpfern den Tatsachen entspricht ist umstritten
Im Vorfeld des letzten Angriffes ließ Alexander Schiffe der Karthager und seiner verbündeten Phönizier zur Evakuierung der Bevölkerung passieren In Heiligtümer oder Tempel Geflüchtete wurden verschont
Zahlreiche Einwohner - die überlieferte Zahl von <num> gilt allerdings als stark übertrieben - wurden in die Sklaverei verkauft Das war in der Antike eine gängige Praxis um die Kriegskassen aufzufüllen
Alexander soll allerdings sehr selten zu diesem Mittel gegriffen haben da er die Bevölkerung für sich gewinnen wollte denn er konnte sich eine ständige Bedrohung durch Aufständische in seinem kaum durchgängig besetzbaren Hinterland nicht leisten
Tyros wurde wieder aufgebaut und neu besiedelt um unter makedonischer Hoheit die beherrschende Position in Phönizien zu sichern
Die Nachricht von diesem mit modernster Kriegstechnik errungenen Sieg - die Belagerungstürme sollen eine Höhe von <num> Metern erreicht haben - machte in der antiken Welt weit über die betroffene Region hinaus einen starken Eindruck
Eroberung von Gaza
Alexander der während der Belagerung auch die Verwaltung und Logistik in den neu gewonnenen Gebieten ordnete brach etwa Anfang September <num> von Tyros auf Die Städte und Stämme im südlichen Syrien ergaben sich bis auf die Hafenstadt Gaza
Die Stadt war seit Jahrhunderten der Hauptumschlagplatz des Gewürzhandels
Mit einer Eroberung der Stadt konnte Alexander einen der lukrativsten Handelsbereiche zwischen Ost und West unter seine Kontrolle bringen doch standen den Makedonen damit nicht nur Perser sondern auch arabische Söldnertruppen gegenüber
Mit entsprechender Härte wurde der Kampf geführt
DateiOlympias<num>JPG
Einen unmittelbaren Gewinn konnte sich Alexander von einer Eroberung nicht versprechen denn die Gewürzhandelsgeschäfte des Jahres waren abgeschlossen da die Route nur einmal im Jahr befahren wurde Wetterverhältnisse und Orientierungsschwächen beschränkten die Aktivitäten mediterraner Seefahrt auf das halbe Jahr zwischen Mai und Oktober in dem das Wetter in der Regel verläßlich gut war
Faktisch lag der Zeitpunkt Mitte August Hesiod <num> v Chr denn es stand auch noch die Rückreise an Organisiert war diese Fahrt bis in die Spätantike als riesiges Kauffahrtgeschwader zuerst entlang der östlichen Küsten - vor allem Kornfrachter Sklaven- und Baumaterial-Transporten sowie Postschiffen und anderen die dann übers Meer von Kriegsschiffen begleitet wurden Durch die Belagerung von Tyros waren die Handelsunternehmen <num> v Chr schon stark beeinträchtigt worden
Alexander nahm sofort den Hafen von Gaza zum Antransport der zerlegten Belagerungsmaschinen in Beschlag
Die Stadt selbst lag nahe dem Meer auf einem flachen Hügel Gaza war auch der letzte freie Ankerplatz für die persische Flotte in Syrien und somit auch an der kompletten östlichen Mittelmeerküste
Die Flotte war mittlerweile in Auflösung begriffen da die griechischen Kontingente nun ebenfalls - klimabedingt - im Herbst in ihre Heimathäfen zurück segelten
Mit erneut hohem Aufwand schütteten die Makedonen einen Damm zur Südseite der Stadt auf der danach mit weiteren konzentrisch angelegten Dämmen ergänzt wurde
Die Kämpfe - vor allem mit den arabischen Söldnern - wurden als wild bezeichnet Alexander wurde zweimal verwundet durch einen Messerstich und - gefährlicher - mit einem Katapultpfeil der durch den Panzer in die Schulter drang
Nach zwei Monaten und dem vierten Ansturm fiel die Stadt um die <num> Verteidiger sollen umgekommen sein Frauen und Kinder wurden als Sklaven verkauft
Dass der Kommandant Batis wie Hektor durch Achilles vor Troja um die Stadt geschleift worden sein soll wird angezweifelt Alexander zog die Bevölkerung der umliegenden philistäischen und arabischen Ortschaften in die Stadt eine dauernde Besatzung machte sie zu einem Waffenplatz der für Syrien und für Ägypten gleich wichtig war
Es wird davon ausgegangen dass der Gewürztransport nach Gaza danach in der Felsenstadt Petra - der davor liegenden Station der Weihrauchstraße - angehalten wurde
Petra war zentrales Weihrauchlager da die Stadt in einem Talkessel gewaltige Lagerhallen Höhlen besaß
In Petra saßen die Ökonomen die kontrollierten was sie zu welchem Preis an die mediterranen Küsten bringen wollten Für <num> war das Geschäft allerdings schon gelaufen
Den jahreszeitlichen Bedingungen zufolge kehrten im Herbst auch die Kauffahrtsflotten zurück und trafen in Phönizien überall in Häfen ein die von den Makedonen kontrolliert wurden
Die Auflösung der persischen Kriegsflotte im Herbst war ebenfalls eine Routineangelegenheit doch war es allen Beteiligten klar dass die Kontingente auf Grund der makedonischen Besetzung sämtlicher Festlandshäfen im östlichen Mittelmeer im nächsten Frühjahr nicht wieder unter persischem Kommando zusammengeführt werden würden
Seekrieg <num> v Chr
Während Alexander mit dem Heer <num> v Chr den größten Teil des Jahres mit Belagerungen zur Vervollständigung seiner Blockade der persischen Seemacht verbrachte - und dabei die phönizischen Hafenstädte und ihren Handel unter seine Kontrolle nahm - war die Flotte der Perser durch den bereits im Frühjahr erfolgten Abzug der phönikischen und kyprischen Kontingente geschwächt und verhielt sich defensiv
Die Admirale Pharnabazos und Autophradates versuchten - meist mit Hilfe begünstigter oder eingesetzter Machthaber - die wichtigsten Inseln unter ihrer Kontrolle zu behalten
In Griechenland das Alexanders Statthalter Antipater bis auf die Peloponnes fest im Griff hatte rührte sich kein Widerstand
Lediglich der Spartanerkönig Agis III setzte noch auf die persische Karte und hatte Kreta durch seinen Bruder und Mitregenten Agesilaos besetzen lassen
Doch schon im Vorjahr noch während des Aufenthalts in Gordion <num> v Chr hatte Alexander Amphoteros den Bruder des Orestiden Krateros beauftragt in Übereinstimmung mit den Abmachungen des Bündnisses eine neue griechische Flotte auszurüsten Dank der erbeuteten Schätze aus Sardis gelangen die Anfänge dazu und nach dem Sieg bei Issos und dem darauf folgenden Winter der keine Flottenunternehmungen zuließ stand Alexanders neue Flotte im Frühjahr <num> v Chr bereit
Nun konnten die makedonischen Nauarchen Hegelochos und Amphoteros ihrerseits systematisch die Inseln besetzen - von Tenedos und Chios wo der persische Admiral Pharnabazos mit der Besatzung von <num> Trieren in Gefangenschaft geriet - bis nach Kos und schließlich Lesbos
Dort handelte der athenische Söldnerführer Chares mit zweitausend Mann freien Abzug aus und begab sich nach Tainaron dem Hafen und Söldnermarkt südlich von Sparta
Amphoteros unterwarf zuletzt noch die kretischen Stützpunkte während Hegelochos bereits nach Ägypten steuerte um selbst die Meldung vom Ausgang des Kampfes gegen die persische Seemacht zu überbringen zugleich die Gefangenen abzuliefern
So war mit dem Ausgang des Jahres <num> der letzte Rest einer persischen Seemacht die das makedonische Heer im Rücken zu gefährden und dessen Bewegungen zu hindern vermocht hätte vernichtet
Besetzung Ägyptens <num>-<num> v Chr
Nach der Eroberung von Gaza machte sich Alexander mit einem Teil seines Heeres auf den Weg nach Ägypten
Ägypten war in den vorangegangenen sieben Jahrzehnten mehrfach von den Persern angegriffen und besetzt worden und ging ihnen regelmäßig durch Aufstände wieder verloren
Erst seit drei Jahren war es wieder in der Hand des Großkönigs doch Ägypten war von Truppen entblößt weil der Satrap Sabakes mit einem großen Aufgebot nach Issos gekommen und selbst dort gefallen war
Mazakes vom Großkönig
zum neuen Satrapen ernannt konnte nicht an Widerstand denken Er übergab unter Auslieferung von <num> Talenten für freies Geleit die Grenzfestung Pelusion
Ein Teil der makedonischen Flotte segelte nun den Nil aufwärts zur Hauptstadt Memphis während sich Alexander mit den Truppen auf dem Landmarsch über Heliopolis dorthin begab
In Memphis opferte Alexander wie er auch den Göttern anderer eroberter Länder Opfer darbrachte dem ägyptischen Gott Apis anstatt ihn zu verachten wie der persische Großkönig Artaxerxes III der den heiligen Stier des Gottes töten ließ
Als Gegengabe scheint Alexander als Pharao des Oberen und Unteren Ägyptens gekrönt worden zu sein wenngleich diese Ehrung nur in dem frei erfundenen
erwähnt wird Die Krönung kann nicht auf einen Monat genau datiert werden bestätigt wird sie aber durch die Pharaonentitel die ihm in ägyptischen Tempelinschriften zugeschrieben sind Der Verlag veröffentlichte dazu das Foto eines Reliefs im Amun-Tempel von Luxor
Alexander zog danach am westlichen Nil entlang nordwärts und gründete im Januar <num> v Chr an der Mittelmeerküste Alexandria die bedeutendste all seiner Stadtgründungen
Im März zog Alexander von Paraetonium
aus <num> km südwestwärts durch die Wüste zum Orakel von Siwa einem dem Gott Amun geweihten Tempel Was er dort an Botschaften empfing ist unbekannt
Antike Quellen berichten Alexander habe dort erfahren dass er der Sohn des Zeus sei so soll ihn der oberste Priester als Sohn des Zeus begrüßt haben
Jedoch hatte Alexander sich schon vorher als Sohn des Zeus bezeichnet
Von Siwa kehrte Alexander nach Memphis zurück verweilte dort einige Wochen und führte seine Truppen dann zurück nach Palästina
Eroberung des persischen Kernlands <num>-<num> v Chr
Im Mai <num> v Chr kehrte Alexander nach Tyros zurück
Er befahl hier den Wiederaufbau der Stadt die er mit befreundeten Phöniziern wieder besiedeln ließ
<num> zusätzliche Soldaten waren im Frühling aus Makedonien entsandt worden und bei Tyros trafen sie im Juli mit Alexander zusammen
Seine Armee bestand nun aus <num> Fußsoldaten und <num> Reitern
Alexander zog ostwärts durch Syrien und überquerte den Euphrat
Sein Plan mag gewesen sein von hier aus südwärts nach Babylon zu ziehen doch eine Armee unter dem persischen Satrapen Mazaeus verstellte den Weg
Alexander vermied die Schlacht die ihn viele Männer gekostet hätte und zog stattdessen nordwärts
Derweil zog Dareios selbst eine neue große Streitmacht in Assyrien zusammen und dieses Heer war es das Alexander treffen wollte
Im September <num> v Chr überquerte das Heer den Tigris
Am <num> September unmittelbar vor der Schlacht kam es zu einer Mondfinsternis die die Perser verunsicherte und von ihnen als schlechtes Omen gedeutet wurde
Das Heer Alexanders lagerte <num> km von der persischen Armee entfernt bei einem Dorf namens Gaugamela weshalb die folgende Schlacht als Schlacht von Gaugamela bekannt wurde
Am <num> Oktober kam es zum Kampf
Wenngleich das Heer des Dareios auch diesmal den Truppen Alexanders zahlenmäßig weit überlegen war siegte abermals Alexander
Er vermochte aber nicht Dareios selbst zu töten oder gefangen zu nehmen
Obwohl dieser damit erneut entkommen war war seine Armee praktisch vernichtet
Alexander dagegen hatte nun die Herrschaft über die Satrapie Babylonien gewonnen und konnte ungehindert ins reiche Babylon einziehen
Mazaeus der sich nach der Schlacht von Gaugamela nach Babylon zurückgezogen hatte übergab die Stadt an Alexander der sie durch das Ischtar-Tor betrat und sich zum König von Asien ausrufen ließ
Während die Griechen die Völker Asiens zuvor als Barbaren verachtet hatten sah Alexander sie mit anderen Augen
Fasziniert von der Pracht Babylons befahl er die Schonung aller Bauwerke
Alexander verzieh dem persischen Satrapen Mazaeus und ernannte ihn zu seinem Statthalter in Babylon
Nach fünfwöchigem Aufenthalt zog Alexander weiter ostwärts um die großen persischen Städte im Kernland anzugreifen
Susa ergab sich kampflos
Im Januar <num> v Chr erreichten die Makedonen die persische Hauptstadt Persepolis
Zahlreiche Einwohner begingen vor seinem Einzug Selbstmord oder flohen
Die ältere Meinung Alexander habe die Stadt plündern und den Königspalast niederbrennen lassen ist inzwischen von der jüngeren Quellenkritik relativiert worden
Archäologische Funde bestätigen dass lediglich die Gebäude die Xerxes I errichtet hatte brannten was die Darstellung Arrians wahrscheinlicher macht
Verfolgung und Tod des Dareios <num> v Chr
DateiDarius IIIjpg
Zwar war Persien nun in Alexanders Hand doch König Dareios III war noch immer am Leben und auf der Flucht
Da Alexander mitgeteilt worden war dass Dareios sich in Medien aufhalte folgte er seiner Spur im Juni nach Nordwesten nach Ekbatana
Doch auch Dareios Anhängerschaft hatte jetzt keine Hoffnung mehr Persien zurückzugewinnen
Die Vollkommenheit der Niederlage ließ nur die Möglichkeit zu sich zu ergeben oder zeitlebens zusammen mit Dareios zu fliehen
Bisthanes ein Mitglied der Königsfamilie entschied sich in Ekbatana zu bleiben wo er Alexander empfing und ihm die Stadt übergab
Alexander zeigte sich wiederum großzügig und ernannte einen Perser zu seinem Statthalter in Medien
In Ekbatana entließ Alexander auch die griechischen Verbündeten und die thessalischen Reiter was als Zeichen zu verstehen war dass der vom Korinthischen Bund beschlossene Rachefeldzug damit beendet war
Teile des Bundesheeres wurden jedoch von Alexander als Söldner angeworben
Dareios setzte inzwischen seine Flucht fort
Er hoffte Zuflucht in Baktrien zu erhalten wo ein Verwandter namens Bessos Satrap war
Bessos aber setzte Dareios gefangen und schickte einen Unterhändler zu Alexander
Er bot ihm an Dareios an die Makedonen zu übergeben wenn im Gegenzug Baktrien frei bliebe
Alexander ging nicht auf die Verhandlungen ein und setzte die Verfolgung fort
Bessos tötete seine Geisel im Juli und floh seinerseits
Die Leiche des Dareios wurde von Alexander nach Persepolis gebracht und dort feierlich beigesetzt
Verfolgung des Bessos <num>-<num> v Chr
In der Zwischenzeit hatte Alexander erkannt dass er zur Sicherung der Herrschaft über das Perserreich die Unterstützung der persischen Adligen brauchte
Er nutzte Dareios Ermordung daher die Perser zu einem Rachezug gegen Bessos aufzurufen der sich nun den Namen Artaxerxes gegeben hatte und sich Großkönig von Persien nannte
Die Soldaten waren wenig begeistert davon dass sie den Tod ihres Erzfeindes vergelten und zudem gemeinsam mit Persern kämpfen sollten
Außerdem war ihnen das Land im Nordosten vollkommen unbekannt
Die dortigen Provinzen Baktrien und Sogdien lagen in etwa auf den Territorien der heutigen Staaten Afghanistan Usbekistan und Turkmenistan
Im August <num> v Chr brach Alexander zu einem neuen Feldzug auf und eroberte zunächst Hyrkanien die persische Satrapie an der Südküste des Kaspischen Meeres
Unter jenen die mit Alexander kämpften war Oxyartes ein Bruder des Dareios
Statt von Hyrkanien den direkten Weg nach Baktrien zu wählen ging Alexander über Aria dessen Satrap Satibarzanes an Dareios Gefangennahme beteiligt gewesen war
Alexander eroberte die Hauptstadt Artacoana verkaufte die Einwohner in die Sklaverei und benannte die Stadt in Alexandreia um der heutige Name der Stadt ist Herat
Auf seinem weiteren Weg kam es zu einem Zwischenfall als Philotas der Sohn des Parmenion beschuldigt wurde einen Anschlag auf Alexanders Leben unternommen zu haben
Ob dieser Versuch wirklich unternommen worden war ist unklar
Vielleicht diente die Affäre Alexander bloß als Vorwand sich Parmenions zu entledigen der zum Wortführer seiner Kritiker avanciert war
Sie missbilligten Alexanders Neigung die Perser zu ehren und ihre Gewänder zu tragen und sahen dies als Anbiederung an ein barbarisches Volk an
Philotas wurde an Ort und Stelle mit einem Speer getötet
Ein Kurier wurde dann zu den Adjutanten des in Ekbatana gebliebenen Parmenion gesandt
Sie töteten Parmenion auf Alexanders Befehl
Nach beschwerlicher Reise entlang des Flusses Tarnak erreichte Alexander im April <num> das Zentrum des heutigen Afghanistan und gründete Alexandria am Hindukusch heute Chârikâr
Von hier aus wollte Alexander das Gebirge überschreiten und auf diesem Wege in Baktrien einfallen
Einer Legende zufolge fand man hier den Berg an den der Titan Prometheus gekettet worden war
Als die Nachricht nach Baktrien gelangte dass Alexander dabei war den Hindukusch zu übersteigen fürchteten die Einwohner von Baktra heute Balch die Bestrafung ihrer Stadt und vertrieben Bessos
Die beschwerliche Überquerung des Gebirges hatte die Soldaten indessen gezwungen manche ihrer Lasttiere zu schlachten
Als sie erschöpft in Baktrien ankamen wurde das Land ihnen kampflos übergeben
Alexander ernannte seinen persischen Vertrauten Artabazos den Vater der Barsine zum Satrapen
Alexander hielt sich nicht lange in Baktra auf und folgte weiterhin Bessos der nordwärts zum Oxus Amudarja geflohen war
Der <num> km lange Marsch durch wasserlose Wüste wurde vielen zum Verhängnis
Bessos hatte inzwischen alle Schiffe zerstören lassen mit denen man den Amudarja hätte überqueren können
Die Makedonen brauchten fünf Tage um genügend Flöße für die Überquerung des Flusses anzufertigen
Dann setzten sie in die Satrapie Sogdien im heutigen Turkmenistan über
Die Begleiter des Bessos wollten nun nicht länger fliehen
Sie meuterten gegen ihn nahmen ihn gefangen und händigten ihn an Alexander aus
Dieser zeigte sich gnadenlos und ließ Bessos die Nase und die Ohren abschneiden
Anschließend übergab Alexander den Verstümmelten an Dareios Bruder Oxyartes damit er ihn nach Medien an den Ort brächte wo Dareios ermordet worden war
Dort wurde Bessos gekreuzigt
Alexander ging indessen weiter nach Norden und erreichte die sogdische Hauptstadt Marakanda heute Samarkand
Alle Satrapien des Perserreichs unterstanden nun Alexander und niemand außer ihm selbst erhob mehr Anspruch auf den Königstitel über Persien
Alexander in Sogdien <num>-<num> v Chr
DateiAlexandreLouvrejpg
Nach der Einnahme von Marakanda zog Alexander noch weiter bis zum Syrdarja und gründete dort im Mai <num> v Chr die Stadt Alexandria Eschatê das entfernteste Alexandria das heutige Chudschand in Tadschikistan
Etwa gleichzeitig erhob sich die Bevölkerung Sogdiens gegen ihn
Anführer der Rebellion die Alexander erhebliche Schwierigkeiten bereitete war ein Mann namens Spitamenes der zuvor Bessos verraten und an Alexander übergeben hatte
Die Sogdier die Alexander zunächst begrüßt hatten nun jedoch sahen dass eine Fremdherrschaft durch eine andere ersetzt wurde machten die makedonischen Besatzungen nieder
Alexander zog Truppen zusammen und marschierte von einer rebellischen Stadt zur anderen belagerte sieben von ihnen und tötete anschließend sämtliche männlichen Einwohner wohl um ein abschreckendes Exempel zu statuieren
In der Zwischenzeit eroberte Spitamenes Marakanda zurück doch Alexander gewann die Stadt erneut wobei Spitamenes allerdings entkam
Da das Heer geschwächt und stark reduziert war musste Alexander von der Verfolgung ablassen
Im Zorn brannte er Dörfer und Felder jener Bauern nieder die die sogdische Revolte unterstützt hatten
Für den Winter <num><num> v Chr zog er sich nach Baktra zurück und erwartete neue Truppen die bald darauf aus dem Westen eintrafen und bitter benötigt wurden
Im Frühling <num> v Chr kehrte Alexander nach Sogdien zurück
Den Quellen zufolge gründete er am Amudarja ein weiteres Alexandria das vielleicht mit der heutigen Siedlung Ai Khanoum identisch ist
Der Kampf gegen die sogdischen Rebellen dauerte das ganze Jahr
Erst Monate später zeigte sich dass die Anhänger des Spitamenes ihren Befehlshaber zu verlassen begannen
Das Haupt des Rebellenführers wurde Alexander schließlich im Dezember <num> v Chr überbracht
Während der Sieg gefeiert wurde kam es zu einem Streit zwischen Alexander und seinem General Kleitos
Kleitos der altmakedonisch gesinnt war sollte demnächst nach Baktrien aufbrechen
Grund war vermutlich sein Alter aber Kleitos sah dies als Herabsetzung an
Es ist auch möglich dass Kleitos bei dieser Gelegenheit Kritik an der Proskynese einem von Alexander übernommenen persischen Hofritual geübt hat
Die Streitenden waren zu diesem Zeitpunkt betrunken und Kleitos hatte Alexanders Vater Philipp zu loben begonnen
Hierdurch fühlte sich Alexander so beleidigt dass es zum Streit kam in dessen Verlauf Alexander vergeblich nach seinen Waffen suchte da sie vorsichtshalber von einem Leibwächter beiseitegelegt worden waren
Alexander der möglicherweise Verrat befürchtete rief in höchster Erregung auf Makedonisch nach einer Lanze entriss einer Wache eine und tötete mit ihr Kleitos seinen Lebensretter am Granikos
Als Alexander wieder bei Besinnung war bereute er diese Tat zutiefst Es heißt er solle geklagt und geweint und versucht haben sich das Leben zu nehmen
Er sah diese Tat jedenfalls als einen seiner schwersten Fehler an
Alexanders Neigung zu übermäßigem Alkoholgenuss - er trank allerdings fast ausschließlich in Gesellschaft - blieb eine Schwäche bei der er häufig die Selbstkontrolle verlor
Das gemeinsame Trinken der Männer selbst gehörte fest zum gesellschaftlichen Leben in der griechischen Welt siehe Symposion
Im folgenden Jahr <num> v Chr eroberte Alexander noch zwei sogdische Bergfestungen
Dann war niemand mehr übrig der ihm Widerstand hätte leisten können
Zwei Jahre hatten die Sogdier sich gegen Alexander erhoben und ihn in immer neue Scharmützel verwickelt
Nach dieser Zeit waren die meisten von ihnen tot oder versklavt
Bevor Alexander nach Baktrien zurückkehrte ließ er <num> Mann Besatzung in den eroberten Gebieten Sogdiens zurück
Alexander in Baktrien <num> v Chr
Zurück in Baktra gab Alexander eine Reihe von Befehlen die seine makedonische Generalität weiter von ihm entfremdete
Da sich baktrische Reiter bei den Feldzügen in Sogdien als hilfreich erwiesen hatten befahl Alexander seinen Generälen <num> junge Perser und Baktrier zu Phalanx-Soldaten auszubilden
Auch in die Kavallerie wurden Einheimische integriert
Die Soldaten akzeptierten die Auflagen widerstrebend denn noch immer trauten sie den Persern nicht
Alexander heiratete in Baktra die sogdische Prinzessin Roxane Tochter eines Mannes namens Oxyartes nicht identisch mit dem gleichnamigen Bruder des Dareios
Durch diese politische Heirat gedachte er zur Befriedung Sogdiens beizutragen
Dafür schickte Alexander seine langjährige Geliebte Barsine und den gemeinsamen unehelichen Sohn Herakles fort
Die Heirat war auch eine Beleidigung für Alexanders Verbündeten Artabazos den Vater der Barsine seinen Statthalter in Baktrien
Außerdem versuchte Alexander das persische Hofritual der Proskynese einzuführen Jeder der vor den König treten wollte musste sich vor ihm verbeugen und das Gesicht auf den Boden pressen
Freie Makedonen und Griechen unterzogen sich einer solchen Unterwerfungsgeste allerdings nur vor den Göttern
Es heißt dass mehrere von Alexanders Generälen sich weigerten sich derart vor ihm zu erniedrigen
Fortan galt sie nur noch für Perser
Alexanders Anordnungen wurden als so befremdlich empfunden dass es diesmal zur offenen Revolte unter den griechischen Soldaten zu kommen drohte
Im Rahmen der sogenannten Pagenverschwörung ließ Alexander auch eine Reihe von einstigen Gefolgsleuten hinrichten darunter seinen Hofbiografen Kallisthenes
Indienfeldzug <num> v Chr
DateiTetradrachm Ptolemaeus I obverse CdM Paris FGM<num>jpg
Nach der Eroberung des gesamten Perserreichs fasste Alexander den Beschluss sein Imperium weiter nach Osten auszudehnen
Indien war für die Griechen ein halblegendäres Land über das sie kaum etwas wussten
Das Land das damals Indien genannt wurde ist nicht identisch mit dem heutigen Staat Indien
Es begann dort wo Persien endete im Osten Afghanistans und umfasste Pakistan und das heutige Indien
Eine definierte Ostgrenze gab es nicht da kein Reisender jemals weit nach Indien vorgedrungen war
Die westlichsten Teile jenes Indiens hatten zu Zeiten Dareios I zu Persien gehört wobei Indien selbst kein geeinter Staat war sondern aus einer Vielzahl wenig bekannter Kleinstaaten bestand
Für den Indienfeldzug gab es keinerlei militärische Notwendigkeit
Die Gründe werden auch heute noch in der Forschung diskutiert ohne dass bisher eine Einigung erzielt worden wäre
Möglicherweise waren es Alexanders Neugier und Kriegslust eine Art irrationales Streben und Sehnsucht nach Erfolgen pothos aber auch Thesen wie die von dem Bestreben seine Autorität durch immer neue militärische Siege zu festigen werden angeführt
Jedenfalls sollte sich der Indienfeldzug als schwere Belastungsprobe erweisen
Anfang des Jahres <num> v Chr
stieß Alexander mit zwei Heeren ins Tal des Flusses Kabul vor das damals ein Teil Indiens war
Der Vorstoß war von besonderer Grausamkeit gekennzeichnet
Immer seltener ließ Alexander gegenüber eroberten Regionen Großmut walten
Städte und Dörfer wurden zerstört und ihre Bevölkerung ermordet
Die zwei Armeen trafen einander am Indus
Alexander machte das Land zwischen Kabul und Indus zur Provinz Gandhara und ernannte seinen Gefolgsmann Nikanor zu deren Statthalter
Am anderen Ufer des Indus wurden Alexanders Truppen von Omphis empfangen dem König von Taxila das etwa <num> km vom heutigen Islamabad entfernt lag
Hier traf Alexander einen Mann namens Kalanos den er aufforderte ihn auf seinen weiteren Feldzügen zu begleiten
Kalanos stimmte zu und wurde Alexanders Ratgeber offensichtlich war er bei den kommenden Verhandlungen mit indischen Führern sehr von Nutzen
Vom Hof des Omphis aus rief Alexander die anderen Staaten des Punjab auf sich ihm zu unterwerfen und ihn als Gott anzuerkennen
Dies verweigerte Poros der König von Pauravas das von Taxila durch den Fluss Hydaspes heute Jhelam getrennt war
Im Mai überquerte Alexander während eines Platzregens den Hydaspes und besiegte eine berittene Einheit unter dem Sohn des Poros
Die Griechen und Perser zogen weiter ostwärts
Zahlenmäßig waren sie dem kleinen Heer des Poros das sie erwartete überlegen doch kamen sie in dem üppig bewaldeten Land mit seinen ständigen Regenfällen schwer zurecht
Außerdem waren Berichte zu ihnen gedrungen dass Poros eine Einheit von Kriegselefanten unterhielt mit denen sich die Griechen nie zuvor gemessen hatten
In der Schlacht am Hydaspes wurden die Inder besiegt
In dieser Schlacht soll Alexanders Pferd Bukephalos im Hydaspes zu Tode gekommen sein obwohl andere Quellen sagen es sei schon vor der Schlacht an Altersschwäche eingegangen
Seinem langjährigen Reittier zu Ehren gründete Alexander die Stadt Bukephala heute wahrscheinlich Jhelam in Pakistan
Poros wurde begnadigt und zu Alexanders Statthalter in Pauravas ernannt
Weiter im Osten am Ganges lag das Königreich Magadha das selbst den Menschen des Punjab kaum bekannt war
Alexander wollte auch dieses Land erobern
Bei heftigem Monsunregen quälte sich die weitgehend demoralisierte Armee ostwärts und hatte einen Hochwasser führenden Fluss nach dem anderen zu überqueren
Ende Juli stand die Überquerung des Hyphasis heute Beas an und von Magadha waren die Soldaten noch weit entfernt
Hier meuterten die Männer und weigerten sich weiterzugehen ihr einziges Bestreben war die Heimkehr
Alexander war außer sich wurde aber letztlich zur Umkehr gezwungen
Am Ufer des Hyphasis gründete er ein weiteres Alexandreia und siedelte hier viele Veteranen an die damit wenig Hoffnung hegen durften jemals wieder nach Griechenland zurückzukehren
Rückkehr nach Persien <num>-<num> v Chr
Der beschwerliche Rückweg zum Hydaspes dauerte bis zum September
In Bukephala war mit dem Bau von <num> Schiffen begonnen worden die den Fluss abwärts zum Indischen Ozean segeln sollten
Dies waren jedoch nicht genug um Alexanders gesamte Armee zu transportieren so dass Fußsoldaten die Schiffe am Ufer begleiten mussten
Im November brachen sie von Bukephala auf doch nach zehn Tagen trafen sie am Zusammenfluss des Hydaspes mit dem Acesines heute Chanab auf Stromschnellen in denen mehrere Schiffe kenterten und viele Griechen ihr Leben verloren
Der weitere Weg führte durch indische Staaten die Alexander nicht unterworfen hatte
Immer wieder wurde das Heer angegriffen und die Perser und Griechen zerstörten Städte und Dörfer wo sie ihnen in den Weg kamen
Im Kampf gegen die Maller wurde Alexander bei der Erstürmung einer Stadt vielleicht Multan
durch einen Pfeil schwer verletzt
Das Geschoss drang in seine Lunge obwohl Alexander überlebte sollte er den Rest seines Lebens unter den Folgen dieser Verwundung leiden
Vom Krankenlager aus befahl er dass am Zusammenfluss von Acesines und Indus ein weiteres Alexandreia nahe dem heutigen Uch gegründet und Roxanes Vater Oxyartes zum Statthalter der neuen Provinz ernannt werden solle
Als Nächstes griff Alexander die Staaten von Sindh an um seiner Armee den Weg nach Süden freizukämpfen
Die Könige Musicanos Oxicanos und Sambos wurden unterworfen
Musicanos der später eine Rebellion anzettelte wurde letztlich gekreuzigt
Erst als der Monsun wieder einsetzte erreichte das Heer <num> v Chr die Indusmündung und den Indischen Ozean
Alexander gründete hier die Stadt Xylinepolis heute Bahmanabad und machte die Flotte gefechtsbereit
Während etwa ein Viertel der Armee so auf dem Seeweg die Rückkehr antreten sollte musste der Großteil über den Landweg nach Persien zurückkehren
Im August <num> v Chr machte sich das Landheer unter Alexanders Führung auf den Weg
Die Flotte unter dem Befehl des Nearchos brach einen Monat später überstürzt auf da sich die Einheimischen zu erheben begonnen hatten
Praktisch unmittelbar nach dem Abzug des Heeres fielen die gerade eroberten Kleinstaaten Indiens ab und erhoben sich gegen die in den neuen Städten zurückgebliebenen Veteranen über deren weiteres Schicksal in den wenigsten Fällen etwas bekannt ist
Das heutige Belutschistan war damals als Gedrosien bekannt
Obwohl die Perser vor der Durchquerung der gedrosischen Wüste warnten ging Alexander dieses Risiko ein wahrscheinlich weil dieser Weg der kürzeste war
Die Hintergründe sind in der Forschung jedoch umstritten
Ob er wirklich die sagenhafte Königin Semiramis übertreffen wollte ist wenigstens fraglich wenn dann ging es Alexander wohl darum die Rückschläge des Indienfeldzugs durch dieses Unternehmen zu relativieren
Auch die Stärke seines Heeres zu diesem Zeitpunkt ist ungewiss von wohl sicher übertriebenen <num> Mann bis zu wahrscheinlich realistischeren <num>
Die sechzigtägigen Strapazen ließen zahllose Soldaten durch Erschöpfung Hitzschlag oder Verdursten ums Leben kommen dabei spielte auch der Umstand eine Rolle dass Alexanders Führer offenbar recht unfähig waren
Im Dezember erreichten die Soldaten Pura heute Bampur einen der östlichsten Vorposten Persiens und waren damit in Sicherheit
Massenhochzeit von Susa Revolte in Opis und Tod Hephaistions <num> v Chr
DateiIstanbul - Museo archeol
- Sarcofago di Alessandro sec IV aC - Foto G Dall<num>Orto <num>-<num>-<num> <num>jpg
Alexander gründete im Januar <num> v Chr ein weiteres Alexandreia heute Golashkerd
Auf dem Weg westwärts stieß er in Susa auf Nearchos und seine Männer die den Seeweg weitgehend unversehrt überstanden hatten
Neue Feiern wurden genutzt um <num> persische Frauen mit Soldaten zu verheiraten - die Massenhochzeit von Susa
Die Ehen wurden von Alexander als Notwendigkeit gesehen um das Zusammenwachsen von Persern und MakedonenGriechen weiter voranzutreiben
Er selbst heiratete zwei Frauen nämlich Stateira eine Tochter des Dareios und Parysatis
Er war somit nun mit drei Frauen verheiratet
Die Hochzeiten wurden nach persischem Ritual begangen
Schon Alexanders Vater hatte die Ehe mit mehreren Frauen als diplomatisches Mittel zur Stabilisierung und Ausweitung seines Machtbereiches eingesetzt
In der Forschung wurde dies als Versuch interpretiert eine Art Verschmelzungspolitik zu betreiben Johann Gustav Droysen
Der britische Historiker Tarn sah darin gar den Versuch einer Vereinigung der Menschheit viele andere moderne Historiker wie Badian oder Bosworth lehnen dies jedoch ab
Um weitere Attribute eines persischen Staates zu übernehmen ernannte Alexander seinen langjährigen Freund Hephaistion und nach dessen Tod Perdikkas zum
Chiliarchen
Wesir und seinen General Ptolemaios zum Vorkoster
Beide Titel waren im Westen unbekannt
Außerdem wurden gegen mehrere Statthalter die sich bereichert hatten oder ihren Aufgaben nicht sachgerecht nachgekommen waren Prozesse eröffnet
Harpalos ein Jugendfreund Alexanders und sein Schatzmeister befürchtete aufgrund seines Verhaltens einen solchen Prozess
Er setzte sich mit <num> Söldnern und <num> Talenten Silber nach Griechenland ab wurde jedoch bald darauf auf Kreta ermordet
Die Neuerungen Alexanders vergrößerten die Kluft zwischen ihm und seiner makedonischen Generalität
Da die Zahl der Soldaten iranischer Herkunft im Heer die der Makedonen zu übertreffen begann fürchteten sie bald gänzlich bedeutungslos zu sein
Perser durften nun auch höhere Ränge in der Armee bekleiden was die Makedonen als unerhört ansahen
Als die Armee die Stadt Opis am Tigris erreichte erlaubte Alexander vielen Makedonen die Rückkehr nach Hause
Was sie vorher ersehnt hatten sahen sie nun als Affront da dies das erste Zeichen ihrer Ersetzung durch Orientalen zu sein schien
Quellen berichten dass manche der Soldaten Alexander wüste Beleidigungen entgegen geschrien hätten
Alexander reagierte indem er sie ihrer Stellungen enthob und drohte die persischen Soldaten gegen sie zu schicken
Die Soldaten entschuldigten sich und ihnen wurde verziehen
<num> griechische Soldaten wurden in den Folgetagen nach Hause geschickt
Im Herbst des Jahres <num> v Chr ging Alexander nach Ekbatana wo Hephaistion nach einem von vielen Trinkgelagen erkrankte und starb
Alexander der wohl lange Jahre Hephaistions Geliebter gewesen war zumindest bis zum Feldzug im Iran war außer sich vor Trauer
Er ließ laut Plutarch den Arzt seines Freundes kreuzigen die Haare von Pferden und Maultieren abrasieren und opfern fastete mehrere Tage und richtete dann ein monumentales Begräbnis aus
Danach ließ er sämtliche Kossaier umbringen
Die Beziehung zwischen Alexander und Hephaistion wird oft mit der zwischen Achilleus und Patroklos gleichgesetzt
Denn da sich das Geschlecht von Alexanders Mutter Olympias auf den Helden aus dem Trojanischen Krieg zurückführte verglich Alexander selbst sich mit Achilles und seinen Freund mit Patroklos
Alexander hatte so wie auch sein Vater Philipp und viele andere Makedonen bzw Griechen seiner Zeit Beziehungen sowohl zu Frauen - er hatte mehrere deren bekannteste und wohl ernsthafteste die zu Roxane war - als auch zu Männern wobei diese teils auch sexueller Natur waren
Gleichgeschlechtliche Beziehungen wurden zu jener Zeit nicht geächtet es kam aber sehr wohl auf den sozialen Status der Partner an
Alexanders letztes Jahr und sein Tod in Babylon <num> v Chr
DateiMid-nineteenth century reconstruction of Alexander<num>s catafalque based on the description by Diodorusjpg
Alexander ließ den persischen königlichen Schatz ausmünzen und warf damit das Vermögen der Achämeniden in das Austauschsystem des Nahen Ostens womit ein steiler Anstieg im Volumen der Markttransaktionen im Mittelmeergebiet finanziert wurde
Dass der attische Münzfuß nunmehr - außer im ptolemäischen Ägypten - allgemein in der hellenistischen Welt galt erleichterte den internationalen Handel und die Schifffahrt
Bei den Olympischen Spielen des Jahres <num> v Chr ließ Alexander das sogenannte Verbanntendekret verkünden mit dem er den griechischen Poleis befahl die jeweils aus politischen Gründen ins Exil getriebenen Bürger wieder aufzunehmen
Dies stellte einen massiven Eingriff in die Autonomie der Städte dar führte zu heftigen Konflikten in den Gemeinwesen und war letztlich der Anlass dafür dass sich Athen und mehrere andere Städte nach dem Tod des Königs im Lamischen Krieg gegen die makedonische Herrschaft erhoben
Im Februar <num> v Chr kehrte Alexander nach Babylon zurück
Hier bereitete er neue Feldzüge vor die zur Einnahme der Arabischen Halbinsel führen sollten
Ob er überdies wie Diodor berichtet auch plante anschließend den westlichen Mittelmeerraum mit Karthago zu erobern ist seit langer Zeit umstritten
In der neueren Forschung geht man zumeist davon aus dass Alexander in der Tat eine solche Expedition vorbereiten ließ da den Makedonen im Jahr <num> während des Lamischen Krieges eine sehr große Flotte zur Verfügung stand die mutmaßlich ursprünglich für das Unternehmen gegen Karthago gebaut worden war Im Mai kurz vor dem geplanten Aufbruch des Heeres gen Arabien verkündete Alexander dass sein toter Freund Hephaistion fortan als Halbgott zu verehren sei nachdem ein Bote aus der Oase Siwa eingetroffen war wo Alexander wegen einer Vergöttlichung Hephaistions angefragt hatte
Aus diesem Anlass veranstaltete er Feiern bei denen er sich wieder dem unmäßigen Trunk hingab
Am nächsten Tag erkrankte er an einem Fieber und am <num> Juni starb er schließlich
Hinsichtlich der Todesursache wurden seither mehrere Thesen diskutiert darunter eine nach der Alexander am West-Nil-Fieber erkrankte
Auch eine Alkoholvergiftung wird immer wieder in Erwägung gezogen
Nach einer in der Antike verbreiteten Überlieferung ist er hingegen vergiftet worden angeblich mit dem giftigen Wasser des Styx
Wahrscheinlicher ist dass seine körperliche Schwächung durch zahlreiche Kampfverletzungen und übermäßigen Weinkonsum zu einer Krankheit geführt hat
Da die Ärzte damals auf die reinigende Wirkung von herbeigeführtem Erbrechen und Durchfall vertrauten war es üblich Weißen Germer in geringen Dosen zu verabreichen
Die überlieferten Symptome Alexanders sind typisch für eine Vergiftung durch Weißen Germer
Möglicherweise verschlechterten die Ärzte seinen Zustand daher durch wiederholte Gaben des Mittels
Der Leichnam Alexanders soll zur Konservierung in Honig gelegt worden sein
Entgegen dem Wunsch des Verstorbenen im Ammonium von Siwa begraben zu werden wurde er in Alexandria beigesetzt
Alexanders letzte Worte auf die Frage wem er sein Reich hinterlassen werde sollen gelautet haben Dem Besten Des Weiteren äußerte Alexander eine dunkle Prophezeiung Er glaube dass seine Freunde große Begräbnisspiele für ihn veranstalten werden Seinen Siegelring übergab er Perdikkas der nach Hephaistions Tod sein engster Vertrauter gewesen war
Alexandergrab
DateiPtolemaeus IampBerenike Ijpg
Alexander hatte eine Beisetzung im Ammonheiligtum der Oase Siwa gewünscht
Erst nach zweijährigen Vorbereitungen setzte sich der Leichenzug in Babylon in Bewegung
Er wurde in Syrien von Ptolemaios dem künftigen König Ptolemaios I in Empfang genommen und nach Ägypten geleitet
Dort wurde der Leichnam aber nicht in die Oase gebracht sondern zunächst in Memphis bestattet Später wohl noch in der Regierungszeit Ptolemaios I spätestens einige Jahre nach seinem Tod wurde er nach Alexandria verlegt nachdem dort eine prächtige Grabstätte für ihn errichtet worden war
Sie wurde unter König Ptolemaios IV durch ein neues Mausoleum ersetzt das dann auch als Grabstätte der Ptolemäer diente die sich wie alle Diadochen auf Alexanders Vorbild beriefen
Die mumifizierte Leiche befand sich in einem goldenen Sarkophag der aber im <num> Jahrhundert v Chr von König Ptolemaios X durch einen gläsernen ersetzt wurde der den Blick auf den einbalsamierten Leichnam freigab
Dieser Schritt Ptolemaios X der später irrtümlich als Grabschändung gedeutet wurde sollte den Alexanderkult fördern
Für Caesar Augustus Septimius Severus und Caracalla sind Besuche am Grab bezeugt
Möglicherweise wurde es während der Stadtunruhen in der Spätantike oder bei einer Naturkatastrophe zerstört
In den Wirren der Spätantike ging die Kenntnis über den Ort der Grabstätte verloren zumindest die Leiche soll laut Libanios noch Ende des <num> Jahrhunderts zu sehen gewesen sein
Der Kirchenvater Johannes Chrysostomos
<num> stellte in einer Predigt die rhetorische Frage nach dem Ort des Alexandergrabs um die Vergänglichkeit des Irdischen zu illustrieren er konnte also mit Sicherheit davon ausgehen dass keiner seiner Hörer wusste wo sich das berühmte Bauwerk befunden hatte Die Erinnerung daran blieb aber noch in islamischer Zeit erhalten im <num> Jahrhundert wurde eine angebliche Grabstätte gezeigt
Im <num> und <num> Jahrhundert berichteten europäische Reisende von einem kleinen Gebäude in Alexandria das als Alexandergrab ausgegeben wurde
Seit dem <num> Jahrhundert sind viele Lokalisierungsversuche unternommen worden die bisher alle fehlgeschlagen sind
Geschichtlicher Ausblick
DateiDiadochen<num>png
Nach Alexanders Tod erwies sich die Loyalität zu seiner Familie die keinen herrschaftsfähigen Nachfolger stellen konnte als sehr begrenzt
Zwar wurde zunächst der Erbanspruch seines geistesschwachen Halbbruders und auch der seines postum geborenen Sohnes anerkannt doch hatte diese Regelung keinen Bestand
Seine Mutter Olympias von Epirus seine Frau Roxane sein Sohn Alexander IV sein illegitimer Sohn Herakles seine Schwester Kleopatra seine Halbschwester Kynane deren Tochter Eurydike und sein Halbbruder Philipp III
Arrhidaios
fanden einen gewaltsamen Tod
Statt der Angehörigen des bisherigen makedonischen Königsgeschlechts übernahmen Alexanders Feldherren als seine Nachfolger Diadochen die Macht
Da keiner von ihnen stark genug war sich als Alleinherrscher durchzusetzen kam es zu einer langen Reihe von Bürgerkriegen in denen man in wechselnden Koalitionen um die Macht rang
Im Verlauf der Diadochenkriege wurde das riesige Reich in Diadochenreiche aufgeteilt
Drei dieser Reiche erwiesen sich als dauerhaft das der Antigoniden in Makedonien bis <num> v Chr das der Seleukiden in Vorderasien bis <num> v Chr und das der Ptolemäer in Ägypten bis <num> v Chr Alexander hinterließ zahlreiche neu gegründete Städte von denen viele seinen Namen trugen die bedeutendste war Alexandreia in Ägypten
Rezeption
Antike
Quellen
Alexander wurde schon zu Lebzeiten eine mythische Gestalt wozu sein Anspruch auf Gottessohnschaft beitrug
Die zeitgenössischen erzählenden Quellen sind nicht oder nur in Fragmenten erhalten Dabei handelte es sich neben den Fragmenten der angeblichen Kanzleidokumente Alexanders Ephemeriden größtenteils um Berichte von Teilnehmern des Alexanderzugs
Der Hofhistoriker Kallisthenes begleitete Alexander um die Taten des Königs aufzuzeichnen und zu verherrlichen
Sein Werk Die Taten Alexanders reichte vielleicht nur bis <num> v Chr hatte jedoch einen enormen Einfluss auf die späteren Alexanderhistoriker
Weitere Verfasser von Alexandergeschichten waren König Ptolemaios I von Ägypten der als Offizier und Hofbeamter in der Nähe Alexanders gelebt hatte Aristobulos der für Alexander Unvorteilhaftes leugnete oder abschwächte sowie Alexanders Flottenbefehlshaber Nearchos und dessen Steuermann Onesikritos
Die stärkste Nachwirkung unter diesen frühen Alexanderhistorikern erzielte Kleitarchos der zwar ein Zeitgenosse aber selbst kein Feldzugsteilnehmer war sondern in Babylon Informationen von Offizieren und Soldaten Alexanders zusammentrug und zu einer rhetorisch ausgeschmückten Darstellung verband wobei er auch sagenhafte Elemente einbezog Zu diesen frühen Legenden gehörte beispielsweise die falsche Behauptung Alexander und Dareios seien einander wiederholt im Nahkampf begegnet
Im <num> Jahrhundert n Chr schrieb der römische Senator Arrian auf der Grundlage der älteren Quellen unter denen er Ptolemaios und Aristobulos bevorzugte seine Anabasis die verlässlichste antike Alexanderquelle
Wahrscheinlich behandelte auch Strabon in seinen nicht erhaltenen Historika Hypomnemata Historische Denkwürdigkeiten das Leben Alexanders seine erhaltene Geographie enthält Informationen aus verlorenen Werken der frühen Alexanderhistoriker
Weitere Nachrichten finden sich im <num> Buch der Universalgeschichte Diodors der sich auf Kleitarchos stützte
Plutarch verfasste eine Lebensbeschreibung Alexanders wobei es ihm mehr auf das Verständnis des Charakters unter moralischem Gesichtspunkt als auf den historischen Ablauf ankam
Quintus Curtius Rufus schrieb eine in der Antike wenig beachtete Alexandergeschichte
Justin wählte für seine Darstellung aus seiner verlorenen Vorlage der Universalgeschichte des Pompeius Trogus vor allem Begebenheiten aus die geeignet waren seine Leserschaft zu unterhalten
Die Berichte von Curtius Diodor und Pompeius Trogus hängen von einer gemeinsamen Quelle ab das Nachrichtenmaterial das sie übereinstimmend überliefern stammt wohl von Kleitarchos
Diese Tradition Vulgata bietet teils wertvolle Informationen Curtius wird in der französischen Forschung leicht gegenüber Arrian favorisiert
Zusätzliches Material ist bei Athenaios sowie in der Metzer Epitome und dem Itinerarium Alexandri überliefert
Nur wenige Fragmente sind von den Werken des Chares von Mytilene und des Ephippos von Olynth erhalten
Legende
DateiNiketerion Alexander CdMjpg
Als Quelle für den historischen Alexander von relativ geringem Wert aber literarisch von außerordentlicher Bedeutung ist der Alexanderroman Mit diesem Begriff bezeichnet man eine Vielzahl von antiken und mittelalterlichen Biografien Alexanders welche seine sagenhaften Taten schildern und verherrlichen
Im Lauf der Jahrhunderte wurde der Stoff fortlaufend literarisch bearbeitet und ausgeschmückt
Die griechische Urfassung in drei Büchern die den Ausgangspunkt für alle späteren Versionen und Übersetzungen in viele Sprachen bildet ist wahrscheinlich im späten <num> Jahrhundert in Ägypten entstanden
Ihr unbekannter Autor der wohl ein Bürger von Alexandria war wird als Pseudo-Kallisthenes bezeichnet weil ein Teil der handschriftlichen Überlieferung das Werk irrtümlich dem Alexanderhistoriker Kallisthenes von Olynth zuschreibt
Diesem Werk lagen ältere nicht erhaltene romanhafte Quellen fiktive Briefe Alexanders und kleinere Erzählungen zugrunde
Der bekannteste unter den Briefen ist ein angeblich von Alexander an Aristoteles gerichtetes Schreiben über die Wunder Indiens das in verkürzter Fassung in den Roman eingebaut wurde und auch separat überliefert ist
Die gängige Bezeichnung Roman bezieht sich auf die literarische Gattung des Antiken Romans
Im Gegensatz zum modernen Roman hielten der Verfasser und seine antike und mittelalterliche Leserschaft an dem Anspruch fest der Inhalt sei Geschichtsschreibung und nicht literarische Erfindung
Die Idee des historischen Alexander er sei ein Sohn des ägyptischen Gottes Ammon Amun verfremdet der Romanautor indem er aus Alexander ein uneheliches Kind macht
Alexanders Vater ist im Roman der aus Ägypten nach Makedonien geflohene König und Zauberer Nektanebos der als Ammon auftritt gemeint ist der Pharao Nektanebos II
Nektanebos verführt die Königin Olympias während der Abwesenheit ihres Gemahls Philipp
Später tötet Alexander der als Sohn Philipps aufwächst seinen leiblichen Vater erst dann erfährt er seine wahre Abstammung
So macht der ägyptische Autor Alexander zum Ägypter Eine weitere wesentliche Neuerung des Pseudo-Kallisthenes ist die Einführung eines nicht historischen Italienzugs Alexanders auf dem der Makedone nach Rom kommt
Rom unterstellt sich ihm ebenso wie alle anderen Reiche des Westens kampflos
Dann unterwirft er in schweren Kämpfen die Völker des Nordens bevor er gegen das Perserreich zieht
Hier zeigt sich das literarische Bedürfnis den Helden auch den Westen und Norden erobern zu lassen damit seine Weltherrschaft vollendet wird
Roxane ist im Roman eine Tochter des Perserkönigs Dareios die dieser sterbend Alexander zur Frau gibt
Das letzte der drei Bücher das den Indienfeldzug und den Tod des Helden behandelt ist besonders stark von Wundern und phantastischen Elementen geprägt
Es schildert auch Alexanders angeblichen Besuch bei der Königin Kandake von Meroe wobei der König in Verkleidung auftritt aber enttarnt wird eine Episode der spätere Bearbeiter des Stoffs eine ursprünglich völlig fehlende erotische Komponente verleihen
Schließlich wird Alexander vergiftet
Im frühen <num> Jahrhundert fertigte Iulius Valerius eine freie lateinische Übersetzung des Alexanderromans an Res gestae Alexandri Magni
Dabei nahm er Hunderte von Erweiterungen Änderungen und Auslassungen vor
Er beseitigte Ungereimtheiten und Formulierungen die den Makedonenkönig in ein ungünstiges Licht rücken konnten und fügte für Alexander vorteilhafte Details ein
Sein Alexander ist eine mit allen Herrschertugenden ausgestattete Idealgestalt er begeht zwar Fehler lernt aber daraus
Ein weiterer Bestandteil der antiken Alexandersage sind fiktive Dialoge des Königs mit den indischen Brahmanen sowie Briefe die angeblich zwischen ihnen ausgetauscht wurden
Dabei versuchen die Inder die Überlegenheit östlicher Weisheit und einer einfachen naturnahen Lebensweise gegenüber der griechischen Zivilisation und dem Machtstreben Alexanders aufzuzeigen
Auch dieses Schrifttum war sowohl griechisch als auch lateinisch verbreitet
Da es um grundsätzliche Fragen der Lebensführung und um Askese ging war die Wirkung in christlicher Zeit beträchtlich
Kult und Vorbildfunktion
Die Herrscher die nach Alexanders Tod in den verschiedenen Teilen seines Reichs an die Macht kamen waren nicht mit ihm blutsverwandt und soweit in Makedonien Loyalität zur herkömmlichen Ordnung vorhanden war galt sie dem Herrscherhaus insgesamt wobei es nicht speziell auf die verwandtschaftliche Nähe zu Alexander ankam
Daher gab es in den Diadochenreichen wenig Anlass für einen offiziellen staatlichen Alexanderkult dieser blieb den einzelnen Städten überlassen
Erst in hoch- und späthellenistischer Zeit wurde der politische Rückgriff auf Alexander zu einem wichtigen propagandistischen Mittel
Einen Sonderfall bildete jedoch Ägypten dessen neue Hauptstadt Alexandria eine Gründung Alexanders und der Ort seines Grabes war
Die dort regierenden Ptolemäer förderten von Anfang an den Alexanderkult im Rahmen ihrer Propaganda
Er bildete aber zunächst keinen zentralen Bestandteil ihrer Herrschaftslegitimation und wurde erst von Ptolemaios X der den Doppelnamen Ptolemaios Alexandros führte intensiv politisch instrumentalisiert
Ein prominenter Gegner der Römer König Mithridates VI von Pontos
<num> v Chr fiel durch seine mit Nachdruck betriebene Alexander-Imitation auf
Er bekleidete sich mit dem Mantel Alexanders den er von den Ptolemäern erbeutet hatte und illustrierte so seinen Anspruch Vorkämpfer des Griechentums und Retter der hellenistischen Monarchie vor den Römern zu sein
Später erbeutete der römische Feldherr Gnaeus Pompeius Magnus der Mithridates besiegte diesen Mantel und trug ihn bei seinem Triumphzug Mit Pompeius dessen Beiname der Große an Alexander erinnerte begann die offenkundige römische Alexander-Imitation zunächst als Reaktion auf die Propaganda des Mithridates
Mehrere römische Feldherren und Kaiser stellten sich propagandistisch in Alexanders Nachfolge sie verglichen sich mit ihm und versuchten seine Erfolge im Osten zu wiederholen
Dabei steigerte sich die Verehrung Alexanders in manchen Fällen zu einer demonstrativen Nachahmung von Äußerlichkeiten
Zu den Verehrern und Nachahmern Alexanders zählten unter den Kaisern insbesondere Trajan Caracalla und mit Vorbehalten Julian Augustus trug zeitweilig auf seinem Siegelring ein Bildnis Alexanders Caligula legte sich den aus Alexandria geholten angeblichen Panzer Alexanders an Nero stellte für einen geplanten Kaukasusfeldzug eine neue Legion auf die er Phalanx Alexanders des Großen nannte Trajan setzte sich einen Helm auf den Alexander getragen haben soll
Kaiser Severus Alexander der ursprünglich Alexianus hieß änderte seinen Namen in Anknüpfung an den Makedonen
Urteile
Einen sehr tiefen und dauerhaften Eindruck hinterließ in Griechenland die Zerstörung Thebens
Sie wurde nicht nur von den Zeitgenossen sondern jahrhundertelang noch in der römischen Kaiserzeit als unerhörte Grausamkeit empfunden die man Alexander zur Last legte und als historisches Musterbeispiel einer entsetzlichen Katastrophe zitiert
Besonders die antiken Redner kamen mit Vorliebe darauf zu sprechen und nutzten diese Gelegenheit bei ihrem Publikum starke Emotionen zu wecken
Es hieß Alexander habe wie ein wildes Tier und als Unmensch apánthrōpos gehandelt
Noch in byzantinischer Zeit wurde diese Deutungstradition rezipiert
Aus philosophischer Sicht wurde Alexander meist negativ beurteilt da seine Lebensweise einen Kontrast zu den philosophischen Idealen der Mäßigung Selbstbeherrschung und Seelenruhe bildete
Insbesondere die Stoiker kritisierten ihn heftig und warfen ihm Hochmut vor ihre Kritik richtete sich auch gegen Aristoteles den Gründer einer rivalisierenden Philosophenschule der als Erzieher Alexanders versagt habe
Auch die Kyniker pflegten Alexander abschätzig zu beurteilen wobei die Anekdote von der Begegnung des Königs mit dem berühmten kynischen Philosophen Diogenes von Sinope den Ansatzpunkt bildete
Ihr zufolge hatte Diogenes Alexander der ihm einen Wunsch freistellte nur gebeten Geh mir aus der Sonne und Alexander soll gesagt haben Wenn ich nicht Alexander wäre wollte ich Diogenes sein In der von Aristoteles gegründeten Philosophenschule der Peripatetiker war die Ablehnung Alexanders ebenfalls ausgeprägt wenn auch nicht durchgängig
Ihr Anlass waren anscheinend ursprünglich Spannungen zwischen Aristoteles und Alexander die noch in der römischen Kaiserzeit ein spätes Echo in einem haltlosen Gerücht fanden wonach Aristoteles ein Gift zubereitet hatte mit dem Alexander ermordet wurde Das negative Alexander-Bild der Philosophen teilte auch Cicero
Er überliefert die berühmte Anekdote von dem gefangenen Seeräuber der von Alexander wegen seiner Übeltaten zur Rede gestellt wurde worauf der Pirat erwiderte er handle in kleinem Maßstab aus demselben Antrieb aus dem der König weltweit dasselbe tue
Besonders drastisch drückte Seneca die stoische Sichtweise aus
Er bezeichnete Alexander als wahnsinnigen Burschen zum Bersten aufgeblasenes Tier Räuber und Plage der Völker Ähnlich äußerte sich Senecas Neffe der Dichter Lucan Der philosophisch orientierte Kaiser Julian der Alexander als Feldherrn bewunderte kritisierte ihn zugleich scharf wegen Maßlosigkeit und unphilosophischer Lebensführung
Unter den philosophisch orientierten Autoren gab es auch eine kleine Minderheit die Alexander Lob spendete
Dazu gehörte Plutarch der in seinen zwei Deklamationen Über das Glück oder die Tugend Alexanders des Großen aus dem König einen Philosophenherrscher machte dessen Eroberungen barbarischen Völkern Recht und Frieden brachten und die Unterworfenen so humanisierten Bei diesen Jugendwerken Plutarchs handelte es sich allerdings um rhetorische Stilübungen die nicht notwendigerweise seine wirkliche Auffassung spiegeln
In seiner Lebensbeschreibung Alexanders äußerte sich Plutarch weit kritischer bemühte sich aber auch um eine Rechtfertigung Alexanders
Dion von Prusa der den an Alexander anknüpfenden Kaiser Trajan bewunderte würdigte die heldenhafte Gesinnung des Makedonenkönigs
Bei den Römern war ein beliebtes Thema die hypothetische Frage wie ein militärischer Konflikt zwischen dem Römischen Reich und Alexander verlaufen wäre
Der Historiker Livius befasste sich eingehend damit und kam zum Ergebnis dass die römischen Heerführer dem Makedonenkönig überlegen waren
Alexander habe seine Siege der militärischen Untüchtigkeit seiner Gegner verdankt
Diese Einschätzung verband Livius mit einem vernichtenden Urteil über Alexanders Charakter der durch die Erfolge des Königs verdorben worden sei
Ähnlich urteilte Curtius Rufus der die Siege des Makedonen mehr auf Glück als auf Tüchtigkeit zurückführte und meinte die Herausbildung tyrannischer Züge in Alexanders Charakter sei ein Ergebnis übermäßigen Erfolgs gewesen
Aus jüdischer Sicht fiel das Urteil über Alexander sehr vorteilhaft aus
Der jüdische Geschichtsschreiber Flavius Josephus beschreibt Gunstbezeugungen des Makedonen für die Juden und behauptet Alexander habe sich als er nach Jerusalem kam vor dem Gott den die Juden verehrten niedergeworfen
Dabei handelt es sich um eine jüdische Abwandlung einer griechischen Erzählung
Im <num> Jahrhundert wurden im Osten des Reichs Bronzemünzen Alexanders wie Amulette getragen
Unter den Kirchenvätern hebt sich Orosius als radikalster Kritiker Alexanders ab
In seiner auf Justin fußenden Historia adversus paganos Geschichte gegen die Heiden schildert er ihn als blutdürstigen grausamen Unmenschen und großen Zerstörer
Mittelalter
DateiThe coronation of Alexanderjpg
Die mittelalterliche Alexander-Rezeption war außerordentlich intensiv und vielfältig Dabei stand das Sagengut im Vordergrund
Die antike Gestalt wurde mittelalterlichen Vorstellungen angepasst beispielsweise erhält der König eine Ritterpromotion Schwertleite
Besonders Dichter regte der Stoff im Westen ebenso wie im Orient zur Bearbeitung an es entstanden über <num> Dichtungen in <num> Sprachen
Quellen
Die grundlegenden antiken Quellen die im Mittelalter in West- und Mitteleuropa zur Verfügung standen waren neben Pseudo-Kallisthenes der eifrig rezipierte Curtius Rufus der nur als Nebenquelle dienende Justin und der viel beachtete Orosius dessen negative Bewertung Alexanders allerdings wenig Beachtung fand
Besonders die märchenhaften Elemente des Alexanderromans machten Eindruck und regten die Phantasie der Bearbeiter zu weiteren Ausformungen an
Der Roman wurde in zahlreiche europäische Sprachen übersetzt wobei lateinische Fassungen die Grundlage bildeten hinzu kamen die teils stark abweichenden Versionen in orientalischen Sprachen Armenisch Altsyrisch Hebräisch Arabisch Persisch Türkisch Äthiopisch Koptisch
Eine wesentliche Rolle spielte ferner die Prophetie im biblischen Buch Daniel
über den Untergang der aufeinanderfolgenden Weltreiche in diesem Licht erschien Alexander der nach mittelalterlicher Deutung das zweite der vier Weltreiche vernichtete und das dritte gründete als Werkzeug Gottes Auch dem ersten Kapitel des ersten Makkabäerbuchs war eine knappe Zusammenfassung von Alexanders Lebensgeschichte zu entnehmen dort las man dass er bis ans Ende der Welt gelangte und die Welt vor ihm verstummte Dieser biblische Hintergrund verlieh ihm zusätzliche Bedeutung
Heldenkatalog
Im Spätmittelalter zählte man Alexander zum Kreis der Neun Guten Helden einem in der volkssprachlichen Literatur beliebten Heldenkatalog der für die Zeit des Alten Testaments die griechisch-römische Antike und die christliche Zeit jeweils die drei größten Helden benannte für die Antike waren es Hektor Alexander und Caesar
Noch breiter als in der Literatur wurde diese Heldenreihe in der Bildenden Kunst Skulptur Malerei Textilkunst rezipiert
Mittellateinische Literatur
DateiAlexander the Great Ghent Ms <num>jpg Das Alexanderbild in der lateinischsprachigen Welt des Mittelalters war großenteils vom lateinischen Alexanderroman geprägt
Im Frühmittelalter ging die Hauptwirkung nicht von der ursprünglichen Fassung der von Iulius Valerius stammenden Übersetzung aus von der nur drei vollständige Handschriften überliefert waren weit bekannter war ein in mehr als <num> Handschriften erhaltener spätestens im <num> Jahrhundert entstandener Auszug Epitome aus diesem Werk
Um <num><num> fertigte der Archipresbyter Leo von Neapel eine neue lateinische Übersetzung des Pseudo-Kallisthenes aus dem Griechischen an die Nativitas et victoria Alexandri Magni Geburt und Sieg Alexanders des Großen die mehrfach - zuletzt noch im <num> Jahrhundert - überarbeitet und erweitert wurde die überarbeiteten Fassungen sind unter dem Titel Historia de preliis Alexandri Magni Geschichte von den Schlachten Alexanders des Großen bekannt
Der Dichter Quilichinus von Spoleto schrieb <num><num> eine Versfassung der Historia de preliis in elegischen Distichen die im Spätmittelalter populär wurde
Noch weit einflussreicher war aber die schon zwischen <num> und <num> verfasste Alexandreis Walters von Châtillon ein Epos in zehn Büchern auf der Grundlage der Darstellung des Curtius Rufus das zur Schullektüre wurde und im <num> Jahrhundert als Schulbuch Vergils Aeneis an Beliebtheit übertraf
Walter verzichtete fast gänzlich auf die Auswertung des im Alexanderroman vorliegenden Materials
Für ihn war Alexander der stets siegreiche Held der sich selbst ebenso wie alle Feinde überwand und so unsterblichen Ruhm erlangte
Das Verhältnis dieser Autoren und ihres Publikums zu Alexander war vor allem von Bewunderung für außerordentliche Heldentaten und von Staunen über das Märchenhafte und Exotische geprägt
Besondere Beachtung fand Alexanders Tod er bot Anlass zu unzähligen religiös-erbaulichen Betrachtungen die auf die Endlichkeit und Nichtigkeit aller menschlichen Größe angesichts des Todes abzielten
Auf diesen Aspekt wiesen unter anderem viele Kleindichtungen hin darunter insbesondere fingierte Grabschriften Alexanders
Besonders fasziniert waren mittelalterliche Leser von einer Erzählung von Alexanders Himmelsflug und Tauchexpedition die Leo von Neapel nach dem griechischen Roman wiedergab
Dieser Sage zufolge wollte der König nicht nur auf der Erdoberfläche die äußersten Grenzen erreichen sondern auch den Himmel und die Tiefe des Ozeans erkunden
Zu diesem Zweck ersann und baute er mit seinen Freunden ein von Greifen gezogenes Luftfahrzeug und ein von Ketten gehaltenes gläsernes Tauchfahrzeug
Der Himmelsflug wurde von mittelalterlichen Künstlern häufig abgebildet
Aus dem <num> Jahrhundert stammt das Iter ad Paradisum Paradiesfahrt die lateinische Version einer jüdischen Sage über Alexanders Versuch das irdische Paradies zu finden den in der Genesis beschriebenen Garten Eden
Neben der Heldenverehrung kamen vereinzelt auch extrem negative Deutungen der Persönlichkeit Alexanders vor
So setzten ihn im <num> Jahrhundert die prominenten Theologen Hugo von St Viktor und Gottfried von Admont mit dem Teufel gleich
Erzählungen aus dem Alexanderroman wurden in Weltchroniken und Enzyklopädien aufgenommen was ihre Rezeption zusätzlich erweiterte
Die lateinische Überlieferung bildete die Grundlage für die volkssprachliche Rezeption
In den volkssprachlichen Literaturen entstanden zahlreiche Prosawerke und Dichtungen über Stoffe der Alexandersage wobei vor allem die verschiedenen lateinischen Fassungen des Pseudo-Kallisthenes die Historia Alexandri des Curtius Rufus und die Alexandreis Walters von Châtillon verarbeitet wurden
Romanische Literaturen
DateiJean Fouquet- The Coronation of Alexander from the book Histoire AncienneJPG
Alberich von Bisinzo Albéric de Pisançon der im frühen <num> Jahrhundert die älteste volkssprachliche Alexander-Biografie verfasste ein nur teilweise erhaltenes Gedicht in frankoprovenzalischem Dialekt verwarf nachdrücklich die Legende von Alexanders unehelicher Geburt und hob seine hochadlige Abstammung von väterlicher und mütterlicher Seite hervor
Er betonte auch die hervorragende Bildung des Herrschers die - einem mittelalterlichen Bildungsideal entsprechend - neben dem Griechischen das der Makedone wie eine Fremdsprache lernen musste auch Latein- und Hebräischkenntnisse umfasst habe Nach der Mitte des <num> Jahrhunderts entstanden weitere französische Gedichte die einzelne Episoden aus Alexanders Leben Belagerung von Tyros Indienfeldzug Lebensende behandelten
Sie wurden im späten <num> Jahrhundert zur Standardversion des altfranzösischen Roman dAlexandre auch Roman dAlixandre zusammengefügt die von allen im romanischen Sprachraum verbreiteten volkssprachlichen Bearbeitungen des Stoffs die stärkste Wirkung erzielte
Dieses Epos besteht aus über <num> <num> Versen Zwölf- und Dreizehnsilbern vom Roman dAlexandre erhielt dieses Versmaß später die Bezeichnung Alexandriner
Der Roman schildert Alexanders Leben durch Verknüpfung von vier Gedichten unterschiedlichen Ursprungs
Dabei kommt zum Altbestand der Alexanderlegende noch eine Reihe von frei erfundenen Personen und Begebenheiten hinzu
Der Autor stellt Alexander im Stil der Chanson de geste wie einen sehr standesbewussten ritterlichen Lehnsherrn des Mittelalters dar
Er hebt dabei besonders die Großzügigkeit seines Helden hervor und präsentiert das Ideal eines harmonischen Verhältnisses zwischen König und Vasallen
Neben epischen Partien besonders in den Kampfschilderungen finden sich auch stärker romanhafte und vom Phantastischen geprägte
Mehrere Dichter fügten später Ergänzungen hinzu insbesondere die einem Publikumsbedürfnis entsprechende Darstellung der Rache für den Giftmord an Alexander In England schrieb Thomas von Kent im späten <num> Jahrhundert einen Alexanderroman in Alexandrinern in anglonormannischer Sprache mit dem Titel Le roman de toute chevalerie
Er akzeptierte im Gegensatz zu allen älteren romanhaften Bearbeitungen des Stoffs problemlos die Vorstellung dass Alexander aus einem Ehebruch seiner Mutter hervorging was für die früheren Autoren ein nicht akzeptabler Makel gewesen war
Im <num> Jahrhundert entstanden Prosafassungen des Roman dAlexandre
Der altfranzösische Prosa-Alexanderroman fand weite Verbreitung
Einen Höhepunkt erreichte die Alexander-Bewunderung im Herzogtum Burgund am Hof Herzog Philipps des Guten
<num> und seines Nachfolgers Karls des Kühnen
Die bedeutendste spanische Bearbeitung des Stoffs ist El libro de Alexandre
Dieses Epos umfasst über <num> <num> Verse Alexandriner und ist damit die umfangreichste epische Dichtung Spaniens aus dem <num> Jahrhundert
Der unbekannte Verfasser ein vorzüglich gebildeter Geistlicher verfolgt ein moralisches Ziel er will dem Leser anhand der erzählten Begebenheiten die vorbildliche Tugendhaftigkeit des Helden vor Augen stellen
In Italien entstand eine Reihe von volkssprachlichen Werken über Alexanders Lebens in Prosa und in Versen deren Grundlage meist die lateinische Historia de preliis war
Die älteste vollständig erhaltene italienische Alexanderdichtung ist die Istoria Alexandri regis von Domenico Scolari aus der ersten Hälfte des <num> Jahrhunderts
Scolari christianisiert seinen Helden weitgehend Alexander ist ein frommer geradezu heiliger Wundertäter
Als Universalmonarch beglückt er die Welt durch Recht und Frieden
Im <num> Jahrhundert erreichte das Interesse an der Alexandersage in Italien seinen Höhepunkt
Deutsche Literatur
Die deutschsprachige Alexandersage und Alexanderdichtung setzte um die Mitte des <num> Jahrhunderts mit dem Alexanderlied des Pfaffen Lamprecht ein der sich eng an Alberichs Versroman hielt
Die drei erhaltenen später bearbeiteten Fassungen von Lamprechts Gedicht der Vorauer Alexander der Straßburger Alexander und der Basler Alexander setzten jedoch in der Bewertung Alexanders unterschiedliche Akzente
Im Vorauer Alexander wird deutliche Kritik am König geübt
Alexander handelt zwar nach dem Willen Gottes wird aber als hochmütig und herrschsüchtig dargestellt die Zerstörung von Tyros wird als schweres Unrecht verurteilt da die Tyrer als treue Untertanen des Perserkönigs nur ihre Pflicht erfüllten
Überdies erscheint er als mitleidlos da er nicht über den Tod der vielen Gefallenen trauert
Andererseits verfügt er aber über Umsicht die ihn seine Neigung zu jähzorniger Unbeherrschtheit überwinden lässt womit er ein Beispiel gibt und sich von dem sehr negativ gezeichneten Dareios abhebt
Alexander wird bewusst als zwiespältige Persönlichkeit gezeichnet Ein einfacheres Alexanderbild entwirft ein aus ritterlich-aristokratischer Sicht wertender Autor im Straßburger Alexander hier wird der König als vorbildlicher Kämpfer Feldherr und Herrscher idealisiert
Als solcher handelt er nicht eigenmächtig sondern sucht den Rat seiner Vasallen
Er ist klug gerecht und gütig und seine schon in der Antike negativ bewertete Neigung zum Jähzorn wird als einigermaßen berechtigt dargestellt Allerdings ist er nicht frei von Hochmut zum vollkommenen Herrscher fehlt ihm die Mäßigung die er aber in seiner letzten Lebensphase doch noch erlangt womit er das Ideal restlos verwirklicht
Im Basler Alexander dominiert ein anderes in der mittelalterlichen Alexander-Rezeption ebenfalls zentrales Element die Freude am Wunderbaren Seltsamen und Exotischen
Diese Behandlung des Stoffs zielt auf das Unterhaltungsbedürfnis eines breiten nicht mehr primär an ritterlichen Idealen orientierten spätmittelalterlichen Publikums
Im <num> Jahrhundert verfasst der Dichter Rudolf von Ems das allerdings unfertig gebliebene Epos Alexander
Er schildert den König als vorbildlich tugendhaften Helden und ritterlichen Fürsten der sich durch seine moralischen Qualitäten als Herrscher legitimiert
Alexander vollzieht als Werkzeug Gottes dessen Willen
Durch ihn werden die Perser die mit ihrem Verhalten den Zorn des Allmächtigen hervorgerufen haben gezüchtigt
Sein Handeln ist Teil der Heilsgeschichte er kann christlichen Herrschern als Vorbild dienen
Ulrich von Etzenbach beschreibt in seinem zwischen <num> und <num> entstandenen Gedicht Alexander <num> Verse den König nicht nur als edlen Ritter sondern auch als überaus frommen Mann Gottes der seine Siege seinem gottgefälligen Verhalten und Gottvertrauen verdankt die ihm zugeschriebenen Tugenden stammen aus der Heiligendarstellung
Ulrich missbilligt allerdings einzelne Taten wie die Ermordung Parmenions darin unterscheidet er sich von Rudolf bei dem Alexander makellos ist und Parmenion sein Schicksal selbst verschuldet
<num> vollendet der nur aus seinem einzigen Werk bekannte Dichter Seifrit seine Alexanderdichtung in der er besonders die Rolle Alexanders als Weltherrscher betont und sich bemüht von seinem Helden den gängigen Vorwurf des Hochmuts fernzuhalten
Im <num> und im <num> Jahrhundert war der Alexanderstoff in neuen Prosabearbeitungen weit verbreitet die eine befindet sich im
Großen Seelentrost
Mitte des <num> Jahrhunderts die andere ist Johann Hartliebs Histori von dem grossen Alexander die nach der Mitte des <num> Jahrhunderts entstand
Beide dienten einem moralischen Zweck doch ihre Verfasser gingen dabei auf völlig entgegengesetzte Weise bewertend vor
Im Großen Seelentrost bietet Alexander das abschreckende Lehrbeispiel eines durch und durch gierigen Menschen den seine Neugier Besitzgier und Machtgier letztlich ins Verderben führt denn er versucht die dem Menschen gesetzten Grenzen zu überschreiten
Bei Hartlieb hingegen ist er ein Vorbild an Mannes- und Fürstentugend und überdies von einem wissenschaftlichen Erkenntnisstreben beseelt
Für mittelalterliche Verhältnisse auffallend ist die positive Wertung der Wissbegierde eines auf die Natur gerichteten Forscherdrangs der Alexander zugeschrieben wird
Im <num> Jahrhundert wurden auch Alexanderdramen geschaffen und aufgeführt doch sind ihre Texte nicht erhalten
Während die mit literarischem Anspruch gestalteten Werke Alexander in der Regel verherrlichen oder zumindest in überwiegend positivem Licht erscheinen lassen werden im religiös-erbaulichen und moralisch belehrenden Prosaschrifttum oft negative Züge des Makedonenkönigs betont dort wird er als abschreckendes Beispiel für Maßlosigkeit und Grausamkeit angeführt
Sein Himmelsflug dient Geistlichen wie Berthold von Regensburg als Symbol für frevelhaften Übermut
Andererseits heben bedeutende Dichter wie Walther von der Vogelweide und Hartmann von Aue Alexanders vorbildliche milte Freigebigkeit hervor
Englische Literatur
Trotz des traditionell großen Interesses am Alexanderstoff in England gab es erst im Spätmittelalter einen Alexanderroman in englischer Sprache die mittelenglische Dichtung Kyng Alisaunder die wohl aus dem frühen <num> Jahrhundert stammt
Sie schildert den König als Helden und hebt seine Großmut hervor verschweigt aber auch nicht seine Maßlosigkeit und Unbesonnenheit Eine Reihe von weiteren Schilderungen von Alexanders Leben fußte auf der Historia de preliis Alexandri Magni die im mittelalterlichen England beliebt war
Byzanz und slawische Länder
DateiSan marco alexanderjpg Auch für die volkstümliche byzantinische Alexander-Rezeption bildete der Roman des Pseudo-Kallisthenes den Ausgangspunkt
Er lag zunächst in einer mittelgriechischen Prosabearbeitung aus dem <num> Jahrhundert vor
In spätbyzantinischer Zeit entstanden mehrere Neufassungen
Hier hat Alexander die Gestalt eines byzantinischen Kaisers angenommen er ist von Gott gesandt und mit allen Ritter- und Herrschertugenden ausgestattet wird aber nicht zum Christen gemacht sondern dem Bereich des Alten Testaments zugeordnet
Er ist mit dem Propheten Jeremia befreundet und wird von ihm beschützt <num> entstand das byzantinische Alexandergedicht
Die beliebteste Szene aus der Alexandersage war in Byzanz der Himmelsflug der in der Bildenden Kunst oft dargestellt wurde
In den süd- und ostslawischen Literaturen wurde der Alexanderstoff stark rezipiert wobei der Weg des Überlieferungsguts vom griechischen Alexanderroman über kirchenslawische Bearbeitungen in die Volkssprachen führte
Eine altbulgarische Fassung des Romans Aleksandria wurde zum Ausgangspunkt der Rezeption in russischen Chroniken
In Russland war der Alexanderroman im Hochmittelalter in mehreren Versionen verbreitet
Im <num> Jahrhundert begann eine neue Version zu dominieren die vom byzantinischen Volksroman ausging und sich durch stark ausgeprägte Merkmale des mittelalterlichen Ritterromans auszeichnete
Besonders beliebt war die serbische Fassung serbischer Alexander oder serbische Alexandreis die auch in Russland Verbreitung fand und Vorlage für die spätmittelalterliche georgische Prosaübersetzung war
In Russland der Ukraine Bulgarien und Rumänien setzte sich dieser Typus der Alexanderlegende durch
Arabische Literatur
In der mittelalterlichen arabischsprachigen Literatur war Alexander unter dem Namen al-Iskandar bekannt da der Anfang seines Namens mit dem arabischen Artikel al verwechselt wurde
Er wurde schon in der vorislamischen Dichtung erwähnt
Folgenreich war seine Identifizierung mit der koranischen Figur des Dhū l-Qarnain der Zweihörnige von dem in Sure <num> erwähnt wird dass er einen Damm gegen Gog und Magog errichtete Verse <num>-<num>
Diese Identifizierung wurde von den muslimischen Gelehrten mehrheitlich aber nicht einhellig akzeptiert
Nach heutigem Forschungsstand ist die Ableitung der Figur Dhū l-Qarnains von Alexander sowie die Herkunft des Motivs aus der altsyrischen christlichen Alexanderlegende eine gesicherte Tatsache Die im Orient verbreitete Bezeichnung Alexanders als zweihörnig taucht schon in einer spätantiken Alexanderlegende in altsyrischer Sprache auf wo Alexander ein christlicher Herrscher ist dem Gott zwei Hörner auf dem Kopf wachsen ließ womit er ihm die Macht verlieh die Königreiche der Welt zu erobern Den ursprünglichen Anlass zur Bezeichnung der Zweihörnige bot die antike bildliche Darstellung Alexanders mit Widderhörnern die auf seine Vergöttlichung deutete Der Gott Zeus Ammon Amun als dessen Sohn Alexander sich betrachtete wurde als Widder oder widderköpfig dargestellt
Im Koran wird die Geschichte des Zweihörnigen dem Propheten geoffenbart denn er soll sie mitteilen wenn er danach gefragt wird
Alexander erscheint darin als frommer Diener Gottes dem die Macht auf der Erde gegeben war und ein Weg zu allem Er gelangte bis zum äußersten Westen der Welt wo die Sonne in einer verschlammten Quelle untergeht und erlangte die Herrschaft über das dort lebende Volk hier ist ein Nachhall von Pseudo-Kallisthenes zu erkennen der Alexander nach Italien kommen und den gesamten Westen einnehmen ließ
Dann schlug der Zweihörnige den Weg zum äußersten Osten ein und gelangte an den Ort wo die Sonne aufgeht daher deuteten die mittelalterlichen Koranausleger die Zweihörnigkeit meist als Zeichen für die Herrschaft über Westen und Osten
Schließlich begab er sich in eine andere Richtung und kam in eine Gegend wo Menschen lebten die von Angriffen zweier Völker der Yāǧūǧ und Māǧūǧ biblisch Gog und Magog bedroht waren und ihn um Hilfe baten
Zum Schutz der Bedrohten baute er ohne einen Lohn zu verlangen zwischen zwei Berghängen einen gigantischen Wall aus Eisen den die Angreifer nicht übersteigen oder durchbrechen konnten Dieser Schutzwall wird bis zum Ende der Welt bestehen
- Eine altsyrische Version der Sage von Alexanders Aussperrung von Gog und Magog in den Revelationes des Pseudo-Methodius wurde ins Griechische und ins Lateinische übersetzt und fand in Europa viel Beachtung
Auch die voranstehende Passage der <num> Sure Verse <num>-<num> scheint von der Alexanderlegende beeinflusst zu sein obwohl in der Version des Korans Mose statt Alexander der Protagonist ist
Ein dort erzähltes Wunder Wiederbelebung eines getrockneten Fisches stammt anscheinend aus dem Alexanderroman es kommt auch in einer spätantiken altsyrischen Version der Legende vor Es ist davon auszugehen dass der Stoff des Alexanderromans zur Entstehungszeit des Korans bereits in arabischer Übersetzung verbreitet war
Die islamische Wertschätzung für Alexander die sich aus seiner Schilderung im Koran ergab führte dazu dass einige Autoren ihn zu den Propheten zählten
Die mittelalterlichen arabischsprachigen Historiker behandelten die Regierung Alexanders eher knapp
Im Gegensatz zu den europäischen christlichen Chronisten gingen bedeutende muslimische Geschichtsschreiber wie Ṭabarī Masʿūdī Ibn al-Aṯīr und Ibn Chaldūn auf die Alexandersage nicht oder nur nebenbei ein sie hielten sich primär an die Überlieferung über den historischen Alexander
Ṭabarī betrachtete seine Quellen kritisch er stützte sich insbesondere auf die Darstellung des bedeutenden Gelehrten Ibn al-Kalbī
<num><num> und stellte die Vernichtung des Perserreichs als notwendig und berechtigt dar da Dareios tyrannisch regiert habe
Die Auseinandersetzung mit dem Legendenstoff war kein Thema der Geschichtsschreiber sondern ein Anliegen der Theologen die sich mit der Koranauslegung befassten Reichhaltiges Legendenmaterial über Alexander war im muslimischen Spanien Al-Andalus verbreitet dort hieß es er habe die Iberische Halbinsel als König beherrscht und in Mérida residiert
Außerdem kommt Alexander auch in der arabischen Weisheitsliteratur vor wo er als Gelehrter und Musikliebhaber beschrieben wird
Sehr oft taucht sein Name in Spruchsammlungen auf wobei die Sprüche teils ihm zugeschrieben werden teils von ihm handeln
Persische und türkische Literatur
DateiIskandar Alexander the Great at the Talking Treejpg
Im Persischen wurde Alexander Iskandar Sikandar oder Eskandar genannt
In der Spätantike war im persischen Sassanidenreich eine Legende verbreitet wonach er der persischen Religion dem Zoroastrismus einen schweren Schlag versetzte indem er religiöse Schriften vernichten ließ
Daher war Alexander bei den Anhängern dieser Religion verhasst und wurde als teuflisches Wesen betrachtet Nach der Islamisierung wirkte sich diese Sage aber im gegenteiligen Sinne aus denn nun machte man aus Alexander einen Vorkämpfer des Monotheismus gegen heidnische Götzendiener
Der berühmte persische Dichter Firdausī
<num> baute eine Version der Alexanderlegende in das iranische Nationalepos
Šāhnāmeh
ein wobei er in manchen Einzelheiten von Pseudo-Kallisthenes abwich
Für ihn war Alexander ein römischer Kaiser und Christ der unter dem Kreuzeszeichen kämpfte offenbar dachte er dabei an die byzantinischen Kaiser Außerdem machte er - wie schon Ṭabarī der persischer Abstammung war - Alexander zu einem Halbbruder des Dareios womit er ihn für das Persertum vereinnahmte aus der Vernichtung des Perserreichs wurde ein Bruderzwist innerhalb der iranischen Herrscherfamilie
<num> schuf der persische Dichter Nezāmi das
Eskandar-Nāme
Alexander-Buch Sein Alexander ist völlig islamisiert er ist ein monotheistischer Held der den Zoroastrismus der Perser mit Feuer und Schwert ausrottet und dafür den Beifall des Dichters erhält
Er unterwirft nicht nur Indien sondern auch China und gelangt im Westen bis nach Spanien
Wie schon bei Firdausī sucht Alexander auch Mekka auf und reinigt dort die Kaaba
Außerdem ist er auch Philosoph und ein großer Förderer der Wissenschaft er befiehlt den Gelehrten das Wissen aller Völker zusammenzutragen
Das Eskandar-Nāme wurde zum Vorbild für einige spätere Dichtungen ähnlicher Art
Die Handschriften der persischen Alexander-Bücher wurden trotz islamischer Bilderverbote ab dem <num> Jahrhundert mit Buchmalerei geschmückt
In Nordindien sorgten die Mogul-Kaiser des <num> Jahrhunderts für die Bebilderung solcher Bücher
Im Jahr <num> verfasste der türkische Dichter Tāǧ ed-Dīn Ibrāhīm Aḥmedī das türkische Alexanderepos Iskendernāme die erste türkische Bearbeitung des Alexanderstoffs
Dafür bildete Nezāmis Alexanderbuch die Grundlage doch verfügte Aḥmedī auch über andere Quellen aus denen er zusätzliches Sagenmaterial bezog
Sein Werk war im Osmanischen Reich lange berühmt und gelangte auch nach Iran und Afghanistan
Hebräische Literatur
Die jüdische Alexanderrezeption war von dem Umstand geprägt dass der Makedone schon in der Antike als Freund des jüdischen Volkes und Diener Gottes betrachtet wurde
In der mittelalterlichen hebräischen Alexanderliteratur floss Material aus unterschiedlichen Traditionen zusammen
Einerseits handelte es sich um Stoff aus dem griechischen Alexanderroman bzw der Historia de preliis andererseits um einzelne Sagen jüdischer Herkunft Verhalten Alexanders in Jerusalem seine Schutzmaßnahme gegen Gog und Magog sein Aufenthalt im irdischen Paradies und weitere Geschichten
Die hebräische Überlieferung wurde nicht nur von der griechischen und lateinischen beeinflusst sondern wirkte auch ihrerseits auf die westeuropäische Alexandersage ein
Weit verbreitet war in der lateinischsprachigen Welt eine von Petrus Comestor eingeführte Variante der Erzählung von Gog und Magog wonach Alexander nicht die wilden Völker Gog und Magog sondern die zehn jüdischen Stämme aussperrte um sie für ihre Abwendung vom wahren Gott zu bestrafen
Äthiopische Alexanderlegende
Ins christliche Äthiopien gelangte der Alexanderroman auf dem Umweg über eine arabische Fassung
Der Stoff wurde für die Bedürfnisse eines geistlich orientierten Publikums stark umgestaltet
Alexander wird zu einem christlichen König der den christlichen Glauben predigt
Er lebt keusch und ist ein Vorbild der Tugendhaftigkeit
Er stirbt wie ein Einsiedler nachdem er sein Vermögen an die Armen verteilt hat
Durch diese besonders weitreichende Umarbeitung des Romans wird er zu einem Erbauungsbuch
Humanismus und Frühe Neuzeit
DateiCharles Le Brun - Entry of Alexander into BabylonJPG
Petrarca behandelte in seinem Werk Über berühmte Männer auch Alexander wobei er sich an Curtius Rufus hielt dessen negative Äußerungen er herausgriff Positives verschwieg er
Die außerordentliche Bekanntheit der Legendengestalt Alexander hielt auch in der Frühen Neuzeit an
So schrieb der Chronist Johannes Aventinus
<num> es sei kein Herr kein Fürst unseren Leuten auch dem gemeinen ungelehrten Mann so bekannt wie Alexander Andererseits drangen aber in der Renaissance die Humanisten zum historischen Alexander vor und taten die Alexandersage als Märchen ab
Die Wiederentdeckung griechischer Quellen insbesondere Arrians die im Mittelalter unbekannt waren ermöglichte einen neuen Zugang zur Epoche Alexanders
Schon der Portugiese Vasco da Lucena der <num> am Hof Karls des Kühnen von Burgund die erste französische Übersetzung der Alexanderbiografie des Curtius Rufus anfertigte übte scharfe Kritik an der Legende in deren Übertreibungen und Wunderglauben er eine Verdunkelung der wahren historischen Leistung Alexanders sah
<num><num> schuf der Maler Albrecht Altdorfer sein berühmtes Gemälde Die Alexanderschlacht
Charles Le Brun malte ab den frühen sechziger Jahren des <num> Jahrhunderts eine Reihe von Szenen aus Alexanders Leben für König Ludwig XIV
Auf Dichter und Romanautoren übte die Gestalt Alexanders weiterhin eine starke Faszination aus
Ab dem <num> Jahrhundert handelt es sich allerdings großenteils um Werke deren Handlung sich - ganz im Gegensatz zur traditionellen Alexandersage - um frei erfundene erotische Verwicklungen dreht und nur noch geringe Ähnlichkeit mit dem ursprünglichen Legendenstoff aufweist
Hans Sachs schrieb <num> eine Tragedia von Alexandro Magno die in sieben Akten die ganze Geschichte Alexanders darstellt
In Frankreich verfasste Jacques de la Taille <num> die Tragödien La Mort de Daire und La Mort dAlexandre und Alexandre Hardy wählte dieselben Titel für zwei seiner Tragödien La Mort dAlexandre <num> und La Mort de Daire <num>
Im weiteren Verlauf des <num> Jahrhunderts folgten zahlreiche Tragödien und Tragikomödien darunter Racines Alexandre le Grand Uraufführung <num>
Noch intensiver war die Rezeption in italienischer Sprache
Antonio Cesti komponierte die Oper Alessandro vincitor di se stesso Uraufführung Venedig <num> Francesco Lucio ein dramma musicale Glamori di Alessandro Magno e di Rossane Libretto von Giacinto Andrea Cicognini <num> zahlreiche Dramen Melodramen Opern und Ballette folgten
Unter den Opern waren besonders erfolgreich Alessandro Magno in Sidone von MarcAntonio Ziani <num> Libretto von Aurelio Aureli die tragicommedia per musica Alessandro in Sidone von Francesco Bartolomeo Conti <num> Libretto Apostolo Zeno und
Alessandro nellIndie
von Leonardo Vinci <num> Libretto Pietro Metastasio sowie vor allem
Alessandro
von Händel Uraufführung in London <num> Libretto von Paolo Antonio Rolli
Gluck verwertete Elemente des Alexanderstoffs sowohl in seiner Oper Poro Alessandro nellIndia Uraufführung Turin <num> Libretto von Metastasio als auch in dem Ballett Alessandro
Zu Beginn des <num> Jahrhunderts schrieb in Spanien der Dichter Lope de Vega die Tragikomödie Las grandezas de Alejandro
Der englische Schriftsteller John Lyly schrieb die Komödie Campaspe Uraufführung <num> die auch unter dem Titel Alexander and Campaspe bekannt ist und von einem Aufenthalt Alexanders in Athen handelt
John Dryden dichtete <num> die Ode Alexanders Feast welche die Basis für das Libretto des <num> vollendeten und uraufgeführten gleichnamigen Oratoriums von Georg Friedrich Händel HWV <num> bildete
In Griechenland wurde von <num> bis ins frühe <num> Jahrhundert die Alexanderlegende in gedruckten Volksbüchern verbreitet zunächst vorwiegend in Versform Rimada <num> Drucke von <num> bis <num> ab dem <num> Jahrhundert meist in Prosa Phyllada
Von insgesamt <num> Drucken der Phyllada aus dem Zeitraum von ca <num> bis <num> erschienen <num> in der zweiten Hälfte des <num> Jahrhunderts
Rezeption in Nordmazedonien
DateiAlexander-Statue-Skopjejpg
Seit der Unabhängigkeitserklärung der früheren jugoslawischen Teilrepublik Mazedonien der heutigen Republik Nordmazedonien im Jahr <num> knüpfte der neue souveräne Staat demonstrativ an die Tradition des antiken Reichs Makedonien an und betrachtete diese als einen wesentlichen Aspekt seiner nationalen Identität
Von offizieller mazedonischer Seite wurde behauptet es gebe eine ethnische und kulturelle Kontinuität vom antiken Makedonien zum heutigen Mazedonien Im Rahmen solcher Traditionspflege förderten mazedonische Behörden auch auf kommunaler Ebene die Verehrung Alexanders des Großen was sich unter anderem in der Errichtung von Alexander-Denkmälern und in der Benennung von Straßen äußert
Im Dezember <num> wurde der Flughafen der mazedonischen Hauptstadt Skopje nach Alexander benannt Aerodrom Skopje Aleksandar Veliki dort wurde eine große Alexander-Büste aufgestellt
<num> wurde die Errichtung einer zwölf Meter hohen Reiterstatue auf einem zehn Meter hohen Sockel im Zentrum von Skopje beschlossen die Alexander nachempfunden war Im Juni <num> wurde dieser Beschluss der in Griechenland Irritation auslöste umgesetzt
Von griechischer Seite wird die Behauptung einer kulturellen Kontinuität zwischen den antiken Makedonen und den heutigen Staatsbürgern der Republik Mazedonien nachdrücklich zurückgewiesen
Daher erscheint auch die mazedonische Alexander-Rezeption aus griechischer Sicht als Provokation da die gesamte Alexander-Tradition ausschließlich ein Teil des griechischen kulturellen Erbes sei
Im Februar <num> beschloss die neue mazedonische Regierung angesichts von Fortschritten bei den Verhandlungen mit Griechenland zum mazedonischen Namensstreit den Flughafen von Skopje und eine Autobahn die den Namen Alexander von Makedonien trug wieder umzubenennen
Moderne Belletristik
In der Moderne hat sich die Belletristik stärker als früher um Nähe zum historischen Alexander bemüht
Zu den bekannteren historischen Romanen aus der ersten Hälfte des <num> Jahrhunderts gehören
Alexander in Babylon
von Jakob Wassermann <num>
Alexander
Roman der Utopie
von Klaus Mann <num> der Alexander als gescheiterten Utopisten darstellt und Iskander von Paul Gurk <num>
Weitere belletristische Darstellungen von Alexanders Leben stammen von Mary Renault Roger Peyrefitte Gisbert Haefs
und Valerio Massimo Manfredi Arno Schmidt lässt in seiner Erzählung Alexander oder Was ist Wahrheit <num> den Ich-Erzähler Lampon eine Wandlung vom Verehrer zum Gegner Alexanders durchmachen
Iron Maiden widmete ihm den in der Metal-Szene sehr populär gewordenen Titel Alexander the Great der <num> im Album Somewhere in Time erstmals veröffentlicht wurde
Beurteilung in der modernen Forschung
Den Ausgangspunkt der modernen wissenschaftlichen Auseinandersetzung mit Alexander bildete die <num> erschienene Geschichte Alexanders des Großen von Johann Gustav Droysen
Droysen betonte die aus seiner Sicht positiven kulturellen Folgen von Alexanders Politik einer Völkervermischung statt einer bloßen makedonischen Herrschaft über unterworfene Barbaren
Er lobte die Wirtschaftspolitik die Städtegründungen und die Förderung der Infrastruktur und meinte auf religiösem Gebiet habe Alexanders Politik die Entstehung einer Weltreligion vorbereitet
Dieser Sichtweise war eine starke Nachwirkung beschieden
Im englischen Sprachraum war ihr Hauptvertreter im <num> Jahrhundert William W Tarn dessen <num> erschienene Alexander-Biografie den Eroberer als Idealisten beschreibt der eine zivilisatorische Mission erfüllen wollte
Dieser Einschätzung deren Grundidee schon bei Plutarch auftaucht steht eine dezidiert negative Wertung gegenüber welche Kernpunkte der antiken Alexanderkritik aufgreift
Die Vertreter dieser Richtung siehe bereits die negative Charakterisierung durch Karl Julius Beloch sowie später Ernst Badian und ähnlich Fritz Schachermeyr daran anschließend Albert B Bosworth Ian Worthington Wolfgang Will unterscheiden sich hinsichtlich der Gewichtung verschiedener Einzelaspekte
Grundsätzlich aber sehen sie in dem Eroberer Alexander primär einen Zerstörer dessen Fähigkeiten sich auf Militärisches beschränkten
Politisch sei er an seinen Fehlern gescheitert
Er habe impulsive irrationale Entscheidungen getroffen und sich mit den Säuberungen unter seinen Vertrauten und Offizieren schließlich in die Isolation manövriert da er niemandem mehr vertrauen konnte
Die militärischen Leistungen Alexanders die früher einhellige Anerkennung fanden werden von den modernen Kritikern relativiert so charakterisiert Badian den Rückmarsch aus Indien als eine von Alexander verschuldete militärische Katastrophe
Waldemar Heckel hingegen hob in jüngerer Zeit Alexanders strategische Fähigkeiten hervor und wandte sich zugleich gegen ein romantisierendes Alexanderbild Vor einer überzogenen Kritik wodurch sozusagen das Pendel von der Heldenverehrung Alexanders in das andere Extrem umzuschlagen droht warnte etwa Frank L Holt der diesen Trend als new orthodoxy bezeichnete
Neben diesen stark wertenden Darstellungen stehen Untersuchungen vor allem aus neuerer und neuester Zeit deren Autoren von vornherein darauf verzichten die Persönlichkeit Alexanders zu erfassen ein Werturteil über sie abzugeben und seine verborgenen Motive zu erkunden was aufgrund der Quellenlage sehr schwierig ist worauf u a Gerhard Wirth hingewiesen hat
Diese Forscher untersuchen vielmehr Alexanders Selbstdarstellung deren Wandel und die sich daraus ergebenden politischen Folgen
Siehe auch
Alexandermosaik
Geschichte des Hellenismus
Alexander Film
Quellen
Waldemar Heckel John C Yardley Alexander the Great
Historical Sources in Translation
Blackwell Oxford <num> ISBN <num>-<num>-<num>-<num>thematisch geordnete Sammlung von Quellenauszügen in englischer Übersetzung mit knappen Kommentaren und weiterführenden Hinweisen als erster Überblick zu empfehlen
Johannes Hahn Alexander in Indien <num>-<num> v Chr Antike Zeugnisse eingeleitet übersetzt und erläutert
Fremde Kulturen in alten Berichten Bd <num>
Thorbecke Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Literatur
Zum historischen Alexander
Pedro Barceló Alexander der Große Wissenschaftliche Buchgesellschaft Darmstadt <num> ISBN <num>-<num>-<num>-<num>
Helmut Berve Das Alexanderreich auf prosopographischer Grundlage <num> Bände Beck München <num> weiterhin grundlegend für Institutionen und Personen
Albert Brian Bosworth Alexander and the East
The Tragedy of Triumph
OxfordNew York <num> teilweise sehr negative Bewertung Alexanders durch einen Historiker der ihm zahlreiche Bücher und Aufsätze gewidmet hat
Albert Brian Bosworth Conquest and Empire
The Reign of Alexander the Great
Cambridge University Press Cambridge <num> <num> ISBN <num>-<num>-<num>-X
Albert Brian Bosworth Alexander the Great
In
The Cambridge Ancient History
<num> Auflage Bd <num> The Fourth Century BC Cambridge University Press Cambridge <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Pierre Briant Darius in the Shadow of Alexander Harvard University Press Cambridge MassachusettsLondon <num>
Pierre Briant Alexander the Great and His Empire A Short Introduction Princeton University Press Princeton <num>
Paul Cartledge Alexander the Great
The Hunt for a New Past
Overlook Press Woodstock New YorkLondon <num> ISBN <num>-<num>-<num>-<num> gut lesbare Darstellung wenngleich eher thematisch als chronologisch gegliedert
Alexander Demandt Alexander der Große Leben und Legende
Beck München <num> ISBN <num>-<num>-<num>-<num>-<num> Rezension bei sehepunkte
Johann Gustav Droysen Geschichte Alexanders des Großen Herausgegeben von Armin Hohlweg u a ars una Neuried <num> ISBN <num>-<num>-<num>-<num> Nachdruck der Ausgabe Gotha <num> vermehrt um einen Anmerkungsteil mit kritischen Kommentaren der Herausgeber und zahlreiche Abbildungen und Karten
Johannes Engels Philipp II
und Alexander der Große
Wissenschaftliche Buchgesellschaft Darmstadt <num> ISBN <num>-<num>-<num>-<num> sehr gute Einführung
Robin Lane Fox Alexander der Große
Eroberer der Welt
<num> Auflage Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num> nicht unumstrittene aber großartig erzählte Darstellung die Alexander recht positiv sieht
Peter Green Alexander of Macedon
A historical Biography
University of California Press BerkeleyLos AngelesLondon <num> ISBN <num>-<num>-<num>-<num> Nachdruck von Penguin Harmondsworth <num> neben Bosworth Lauffer und Lane Fox eine der besten modernen Alexander-Biografien
Hans-Joachim Gehrke Alexander der Grosse <num> aktualisierte Auflage
Beck München <num> ISBN <num>-<num>-<num>-<num>-<num>
Nicholas G L Hammond Alexander der Große
Feldherr und Staatsmann
Ullstein Berlin <num> ISBN <num>-<num>-<num>-X
Svend Hansen Alfried Wieczorek Michael Tellenbach Hrsg
Alexander der Große und die Öffnung der Welt
Asiens Kulturen im Wandel
Schnell
Steiner Regensburg <num> ISBN <num>-<num>-<num>-<num>-<num> Begleitband zur gleichnamigen Ausstellung in den Reiss-Engelhorn-Museen in Mannheim mit ca <num> Farbabbildungen und Essays von Wissenschaftlern verschiedener Fachrichtungen
Waldemar Heckel The Marshals of Alexanders Empire Routledge London <num> ISBN <num>-<num>-<num>-<num> nützliches prosopografisches Handbuch
Waldemar Heckel Whos Who in the Age of Alexander the Great
Prosopography of Alexanders Empire
Blackwell Oxford u a <num> ISBN <num>-<num>-<num>-<num>
Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great
A new History
Blackwell Oxford u a <num> aktuelle und nützliche Sammlung von Beiträgen zu verschiedenen Schlüsselthemen wie Eroberungen Armee Hof Persien Privatleben Rezeption
Siegfried Lauffer Alexander der Große <num> Auflage dtv München <num> ISBN <num>-<num>-<num>-<num> deutsche Kurzdarstellung sehr quellennah
Sabine Müller Alexander der Große
Eroberung - Politik - Rezeption
Kohlhammer Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Joseph Roisman Hrsg Brills companion to Alexander the Great Brill Leiden <num> ISBN <num>-<num>-<num>-<num> Sammelband mit Beiträgen zu verschiedenen Schlüsselthemen darunter Alexander als Stratege Selbstdarstellung der Hof
Fritz Schachermeyr Alexander der Grosse
Das Problem seiner Persönlichkeit und seines Wirkens
Wien <num> umfassende Darstellung die teilweise mit den vorherigen zumeist positiven Alexanderbildern brach
Jakob Seibert Alexander der Große
Erträge der Forschung Bd <num>
Wissenschaftliche Buchgesellschaft Darmstadt <num> ISBN <num>-<num>-<num>-<num>
William W Tarn Alexander the Great <num> Bände Cambridge University Press Cambridge <num> deutsch <num> Nachdruck in einem Band <num> teilweise sehr romantisierende Darstellung wobei Alexander ausgesprochen positiv beurteilt wird Bd <num> bietet einen Überblick über die Quellen sowie Einzeluntersuchungen
Hans-Ulrich Wiemer Alexander der Große Beck München <num> ISBN <num>-<num>-<num>-<num> solide Einführung
Wolfgang Will Alexander der Große
Urban Taschenbücher Bd <num>
Kohlhammer Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Wolfgang Will Hrsg Zu Alexander dem Großen
Festschrift Gerhard Wirth zum <num> Geburtstag
<num> Bände Hakkert Amsterdam <num>-<num>
Gerhard Wirth Alexander der Große mit Selbstzeugnissen und Bilddokumenten
Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num>
Ian Worthington By the Spear
Philip II Alexander the Great and the Rise and Fall of the Macedonian Empire
Oxford University Press Oxford <num>
Ian Worthington Hrsg Alexander the Great
A Reader
Routledge London <num> ISBN <num>-<num>-<num>-<num> Aufsatzsammlung in der auch Quellen zumeist aus den
Fragmenten der griechischen Historiker
in englischer Übersetzung zitiert werden
Rezeptionsgeschichte
Antike
Jean-Michel Croisille Hrsg Neronia IV
Alejandro Magno modelo de los emperadores romanos
Latomus Bruxelles <num> ISBN <num>-<num>-<num>-<num>
Karsten Dahmen The Legend of Alexander the Great on Greek and Roman Coins Routledge London <num> ISBN <num>-<num>-<num>-<num>
Siegmar Döpp Alexander in spätlateinischer Literatur In Göttinger Forum für Altertumswissenschaft <num> <num> S <num>-<num> PDF
Hans-Ulrich Wiemer Hero God or Tyrant
Alexander the Great in the Early Hellenistic Period
In Henning Börm Hrsg Antimonarchic Discourse in Antiquity
Steiner Stuttgart <num> S <num>-<num>
Mittelalter
Willem J Aerts Hrsg Alexander the Great in the Middle Ages
Ten Studies on the Last Days of Alexander in Literary and Historical Writing
Alfa Nijmegen <num>
George Cary The Medieval Alexander Cambridge University Press Cambridge <num>
Heribert J Gleixner Das Alexanderbild der Byzantiner Salzer München <num>
Laurence Harf-Lancner u a Hrsg Alexandre le Grand dans les littératures occidentales et proche-orientales
Centre des Sciences de la Littérature Nanterre <num>
Tilman Nagel Alexander der Große in der frühislamischen Volksliteratur
Beiträge zur Sprach- und Kulturgeschichte des Orients Band <num>
Verlag für Orientkunde Walldorf <num> ISBN <num>-<num>-<num>-<num>-<num>
Richard Stoneman Alexander the Great
A Life in Legend
Yale University Press New Haven <num> ISBN <num>-<num>-<num>-<num>-<num>
Zachary David Zuwiyya Hrsg A Companion to Alexander Literature in the Middle Ages Brill Leiden
Boston <num>
Neuzeit
Jan Cölln Alexander der Große in Europa und Asien
Mythisierung von Geschichte und ihre Präsenz nach dem Ersten Weltkrieg
In
Antike und Abendland
<num> <num> S <num>-<num>
Georg Veloudis Der neugriechische Alexander
Tradition in Bewahrung und Wandel
Miscellanea Byzantina Monacensia Band <num>
Universität Institut für Byzantinistik und Neugriechisch Philologie München <num> Juli <num>
Dissertation Universität München <num> <num> Seiten unter dem Titel Giōrgos Athanasiu Beludēs Alexander der Große
Ein alter Neugrieche
gekürzte Buchhandelsausgabe <num> Seiten
Tusculum-Schriften
Heimeran München <num>
Weblinks
Teils sehr kritische Betrachtung von Prof Worthington zuerst erschienen im Ancient History Bulletin <num> <num> Lesenswerter Artikel bei der BBC verfasst von Prof Paul Cartledge Das große Alexanderschlacht-Mosaik aus Pompeji Oliver Stones Filmadaption Alexanderprojekt der TU Braunschweig Ausstellung <num> der Reiss-Engelhorn-Museen in Mannheim
Anmerkungen
Plutarch Alexander <num> englische Übersetzung Plutarch Alexander <num> englische Übersetzung Plutarch Alexander <num> Herodot Historien <num> Siehe die Quellenzeugnisse bei Heckel Yardley Alexander S <num> f und Eugene N Borza Greeks and Macedonians in the Age of Alexander The Source Traditions In Transitions to Empire Essays in Greco-Roman History <num>-<num> BC in honor of E Badian Norman <num> S <num>-<num> siehe auch hier Anderer Meinung ist Nicholas G L Hammond Literary evidence for Macedonian speech In Historia <num><num> <num> S <num>-<num> Im Folgenden wird mit Makedonen nur die Herkunft aus dem antiken Makedonien ausgedrückt Peter Green Alexander of Macedon Berkeley <num> S <num> f Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten III<num>-IV<num> httpia<num>usarchiveorg<num>itemsoxyrhynchuspapyr<num>grenuoftoxyrhynchuspapyr<num>grenuoft_bwpdf Die antiken Quellen darunter Plutarch Alexander <num>-<num> und Justin Historiarum Philippicarum libri XLIV <num>-<num> <num><num>-<num> sowie Diodor Bibliothéke historiké <num> <num> - <num> <num> widersprechen sich Die neuere Forschung wird bei Hans-Joachim Gehrke Geschichte des Hellenismus München <num> S <num> diskutiert Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten III<num>-IV<num> httpia<num>usarchiveorg<num>itemsoxyrhynchuspapyr<num>grenuoftoxyrhynchuspapyr<num>grenuoft_bwpdf Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten IV<num>-<num> httpia<num>usarchiveorg<num>itemsoxyrhynchuspapyr<num>grenuoftoxyrhynchuspapyr<num>grenuoft_bwpdf Vgl dazu Jakob Seibert Panhellenischer Kreuzzug Nationalkrieg Rachefeldzug oder makedonischer Eroberungskrieg Überlegungen zu den Ursachen des Krieges gegen Persien In Wolfgang Will Hrsg Alexander der Große Eine Welteroberung und ihr Hintergrund Vorträge des Internationalen Bonner Alexanderkolloquiums <num>-<num> Dezember <num> Bonn <num> S <num> ff Karl Julius Beloch Griechische Geschichte <num> Auflage Bd <num> S <num> vgl Siegfried Lauffer Alexander der Große <num> Auflage München <num> S <num> Curtius Historiae Alexandri Magni Macedonis <num><num>-<num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Robin Lane Fox Alexander der Große Stuttgart <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen hrsg von Armin Hohlweg u a Neuried <num> Nachdruck der Ausgabe Gotha <num> S <num>f und Anm <num> der Herausgeber Robin Lane Fox Alexander der Große Stuttgart <num> S <num> Arrian Anabasis <num> Alexander Demandt Alexander der Große Leben und Legende München <num> S <num> Demandt führt dazu an Diodor Bibliothéke historiké <num> <num> <num> <num> <num> <num> Curtius Rufus Historiae Alexandri Magni Macedonis <num> <num> Justin Historiarum Philippicarum libri XLIV <num> <num> <num> Nicholas Hammond Alexander der Große Berlin <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> und Robin Lane Fox Alexander der Große Stuttgart <num> S <num> William Linn Westermann The Slave Systems of Greek and Roman Antiquity Philadelphia <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Zeitangabe nach Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck über die exakte Datierung gibt es unterschiedliche Angaben Frank Rainer Scheck Die Weihrauchstraße Von Arabien nach Rom - auf den Spuren antiker Weltkulturen Bergisch Gladbach <num> S <num>-<num> Frank Rainer Scheck Die Weihrauchstraße Bergisch Gladbach <num> S <num> Nicolas Hammond Alexander der Große Berlin <num> S <num> Diese Version ist zu verwerfen Historisierende Ausschmückungen sind meist Curtius Rufus der sich auf Kleitarchos bezog zuzuordnen Diese Vulgata genannte einer einzigen Tradition folgende Darstellung hier Kleitarchos
machte Alexander erst zu der umstrittenen Person deren Beurteilung das antike Publikum und die modernen Historiker spaltete Wolfgang Will Alexander der Große Darmstadt <num> S <num> In der Zeit des Römers Curtius
konnte die zeitgenössische Kritik an den römischen Kaisern im <num> Jhdt n Chr nur heimlich geäußert werden
und sich an Alexander - stellvertretend - offen zeigen Wolfgang Will Alexander der Große Darmstadt <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Frank Rainer Scheck Die Weihrauchstraße Bergisch Gladbach <num> S <num> Robin Lane Fox Alexander der Große Stuttgart <num> S <num> f Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> f Günther Hölbl Geschichte des Ptolemäerreiches Darmstadt <num> S <num> Robin Lane Fox Alexander der Große S <num> Gerhard Wirth <num> gibt hierzu die Quelle an Pseudo-Kallisthenes <num> <num> <num> S <num> Text und Bild Robin Lane Fox Alexander der Große Rowohlt Taschenbuch Verlag Reinbek bei Hamburg <num> Original <num> S <num> ISBN <num>-<num>-<num>-<num>-<num> Siehe auch die anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten IV<num>-<num> Volltext als PDF-Datei Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten V<num>-<num> Volltext als PDF-Datei Für die Kämpfe in der Satrapie Baktrien vgl Frank L Holt Into the Land of Bones Alexander the Great in Afghanistan Berkeley <num> Einen knappen Überblick bietet etwa Albert Brian Bosworth The Indian campaigns <num>-<num> BC In J Roisman Hrsg Brills Companion to Alexander the Great S <num>-<num> Vgl Bosworth Alexander Euripides and Dionysos The motivation for apotheosis In Robert W Wallace Edward M Harris Hrsg Transitions to empire Essays in Greco-Roman history <num>-<num> BC Oklahoma <num> S <num>-<num> Johannes Hahn Hrsg Alexander in Indien <num>-<num> v Chr Stuttgart <num> Zur Lokalisierung vgl Siegfried Lauffer Alexander der Große <num> Auflage München <num> S <num> Anm <num> Vgl Ernst Badian Alexander the Great and the Unity of Mankind In Historia Nr <num> <num> S <num>-<num> Allgemeiner Überblick bei Daniel Ogden Alexanders Sex Life In Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great A New History Chichester <num> S <num> ff Fritz Moritz Heichelheim Wirtschaftsgeschichte des Altertums Band <num> Leiden <num> S <num> Diodor Bibliothéke historiké <num><num>-<num> Vgl Albert Brian Bosworth Alexanders last Plans In Albert B Bosworth Hrsg From Arrian to Alexander Studies in Historical Interpretation Oxford <num> S <num> ff Laut Plutarch Alexander <num> starb er am <num> Daisios entsprechend dem <num> Juni <num> v Chr Diodor Bibliothéke historiké <num> <num> <num> Diskussion dazu bei Michael Rathmann Perdikkas zwischen <num> und <num> Nachlassverwalter des Alexanderreiches oder Autokrat Wien <num> S <num>-<num> Rezension Zum Ort dieser Grabstätte siehe Andreas Schmidt-Colinet Das Grab Alexanders des Großen in Memphis In Margaret Bridges Johann Ch Bürgel Hrsg The Problematics of Power Eastern and Western Representations of Alexander the Great Bern <num> S <num>-<num> Zum politischen Hintergrund siehe Claudia Bohm Imitatio Alexandri im Hellenismus München <num> S <num>-<num> Harry E Tzalas The Tomb of Alexander the Great- The history and the legend in the Greco-Roman and Arab times In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Tzalas stellt S <num>-<num> die Quellenzeugnisse über das Grab zusammen Zur Geschichte der Suche siehe Harry E Tzalas The Tomb of Alexander the Great- The history and the legend in the Greco-Roman and Arab times In Graeco-Arabica <num> <num> S <num>-<num> hier <num> f <num>-<num> Zu den Einzelheiten siehe die gründliche Untersuchung von Peter Marshall Fraser Cities of Alexander the Great Oxford <num> Städteliste S <num>-<num> Karten S <num>-<num> Vgl Lionel Pearson The lost histories of Alexander the Great New York <num> Onlineversion Zu den Anfängen der Alexanderlegenden bei den Zeitgenossen des Königs siehe Erwin Mederer Die Alexanderlegenden bei den ältesten Alexanderhistorikern Stuttgart <num> Ben Edwin Perry The Ancient Romances Berkeley <num> S <num> Hartmut Bohmhammel Valerius Übertragung der Alexandergeschichte und ihre gesellschaftlichen Tendenzen Dissertation TU Berlin <num> S <num> Zur Nektanebos-Legende siehe Richard Stoneman Alexander the Great A Life in Legend New Haven <num> S <num> ff Hartmut Bohmhammel Valerius Übertragung der Alexandergeschichte und ihre gesellschaftlichen Tendenzen Dissertation TU Berlin <num> S <num>-<num> Eine eingehende Untersuchung dieses Teils der Alexandersage und seiner Nachwirkung in der Patristik und im Mittelalter bietet Florian Kragl Die Weisheit des Fremden Studien zur mittelalterlichen Alexandertradition Bern <num> Zur Frage des Alexanderkults und der Popularität Alexanders in den Diadochenreichen siehe Robert Malcolm Errington Alexander in the Hellenistic World In Alexandre le Grand Image et réalité Genf <num> S <num>-<num> <num>-<num> Alfred Heuß Alexander der Große und die politische Ideologie des Altertums In Antike und Abendland <num> <num> S <num> f Alexander Meeus Alexanders Image in the Age of the Successors In Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great A New History Chichester <num> S <num>-<num> und die Untersuchung von Claudia Bohm Imitatio Alexandri im Hellenismus München <num> Claudia Bohm Imitatio Alexandri im Hellenismus München <num> S <num> <num> ff <num> Gerhard Wirth Alexander und Rom In Alexandre le Grand Image et réalité Genf <num> S <num>-<num> Otto Weippert Alexander-Imitatio und römische Politik in republikanischer Zeit Augsburg <num> S <num> ff Diana Spencer Roman Alexanders Epistemology and Identity In Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great A New History Chichester <num> S <num>-<num> hier <num>-<num> Siehe dazu Corinne Jouanno Un épisode embarrassant de lhistoire dAlexandre la prise de Thèbes In Ktèma <num> <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num> Erwin Mederer Die Alexanderlegenden bei den ältesten Alexanderhistorikern Stuttgart <num> S <num>-<num> Zu Senecas Alexander-Rezeption siehe Alfred Heuß Alexander der Große und die politische Ideologie des Altertums In Antike und Abendland <num> <num> S <num>f zur philosophischen Alexanderkritik allgemein Johannes Stroux Die stoische Beurteilung Alexanders des Großen In
Philologus
<num> <num> S <num>-<num> und William W Tarn Alexander Cynics and Stoics In American Journal of Philology <num> <num> S <num>-<num> hier <num>-<num> Lucan Bellum civile <num>-<num> Gerhard Wirth Der Weg in die Vergessenheit Wien <num> S <num>-<num> Alfred Heuß Alexander der Große und die politische Ideologie des Altertums In Antike und Abendland <num> <num> S <num> f Ernst Bammel Der Zeuge des Judentums In Wolfgang Will Hrsg Zu Alexander dem Großen Bd <num> Amsterdam <num> S <num> vgl Gerhard Wirth Der Weg in die Vergessenheit Wien <num> S <num>-<num> Johannes Chrysostomos Ad illuminandos catechesis <num> Zum Alexanderbild des Orosius siehe Siegmar Döpp Alexander in spätlateinischer Literatur In Göttinger Forum für Altertumswissenschaft <num> <num> S <num>-<num> hier <num>-<num> online PDF <num> kB Aktueller Überblick bei Zachary David Zuwiyya Hrsg A Companion to Alexander Literature in the Middle Ages LeidenBoston <num> Herwig Buntz Die deutsche Alexanderdichtung des Mittelalters Stuttgart <num> S <num> Das grundlegende Standardwerk für die mittelalterliche Alexander-Rezeption ist George Cary The Medieval Alexander Cambridge <num> Zu den orientalischen Versionen siehe Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num>Dan <num> <num>-<num> sowie Dan <num> und <num> Zur antiken und mittelalterlichen Auslegung siehe Hartmut Wulfram Der Übergang vom persischen zum makedonischen Weltreich bei Curtius Rufus und Walter von Châtillon In Ulrich Mölk Hrsg Herrschaft Ideologie und Geschichtskonzeption in Alexanderdichtungen des Mittelalters Göttingen <num> S <num> ff Victor M Schmidt A Legend and its Image The Aerial Flight of Alexander the Great in Medieval Art Groningen <num> Untersuchung mit zahlreichen Abbildungen Siehe auch Richard Stoneman Alexander the Great A Life in Legend New Haven <num> S <num>-<num> Gottfried von Admont Homilia XVI In Jacques Paul Migne Patrologia Latina Bd <num> Sp <num> f Hugo von St Viktor Allegoriae in Vetus Testamentum <num> In Migne Patrologia Latina Bd <num> Sp <num> f Trude Ehlert Deutschsprachige Alexanderdichtung des Mittelalters Frankfurt am Main <num> S <num> f Siehe auch Ulrich Mölk Alberics Alexanderlied In Jan Cölln u a Hrsg Alexanderdichtungen im Mittelalter Göttingen <num> S <num>-<num> Eine Übersicht über die französische Dichtung bietet David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num> vertiefte Darstellungen bieten Martin Gosman La légende dAlexandre le Grand dans la littérature française du <num>e siècle Amsterdam <num> und Catherine Gaullier-Bougassas Les romans dAlexandre Aux frontières de lépique et du romanesque Paris <num> Die Geschichte der Alexanderrezeption im italienischen Mittelalter beschreibt Joachim Storost Studien zur Alexandersage in der älteren italienischen Literatur Halle Saale <num> Trude Ehlert Deutschsprachige Alexanderdichtung des Mittelalters Frankfurt am Main <num> S <num>-<num> <num> Christoph Mackert Die Alexandergeschichte in der Version des pfaffen Lambrecht München <num> S <num> f <num>-<num> <num>-<num> <num> ff Trude Ehlert Deutschsprachige Alexanderdichtung des Mittelalters Frankfurt am Main <num> S <num>-<num> Zu diesem Werk siehe Gerrit Bunt Alexander the Great in the literature of Medieval Britain Groningen <num> S <num>-<num> Heribert J Gleixner Das Alexanderbild der Byzantiner München <num> S <num>-<num> <num>-<num> Willem J Aerts The Last Days of Alexander the Great according to the Byzantine Alexander Poem in Willem J Aerts Hrsg Alexander the Great in the Middle Ages Ten Studies on the Last Days of Alexander in Literary and Historical Writing Nijmegen <num> S <num>-<num> und S <num> f zur Datierung Hierzu und zu islamischen Auslegungen der Koranstelle siehe Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num>-<num> Alexander Demandt Alexander im Islam In Monika Schuol Udo Hartmann Andreas Luther Hrsg Grenzüberschreitungen Formen des Kontakts zwischen Orient und Okzident im Altertum Stuttgart <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num>-<num> zuletzt Kevin van Bladel The Alexander Legend in the Quran <num>-<num> in Gabriel S Reynolds Hrsg The Quran in Its Historical Context London <num> S <num>-<num> Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Dominique Svenson Darstellungen hellenistischer Könige mit Götterattributen Frankfurt am Main <num> S <num>-<num> Zum antiken Ursprung dieses Sagenmotivs siehe Alexander Demandt Alexander im Islam In Monika Schuol u a Hrsg Grenzüberschreitungen Stuttgart <num> S <num>-<num> hier <num> f Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Die Stelle ist Pseudo-Kallisthenes Vita Alexandri Magni <num><num> Skeptisch äußerte sich allerdings Brannon M Wheeler Moses or Alexander Early Islamic Exegesis of Quran <num>-<num> In
Journal of Near Eastern Studies
<num> <num> S <num> ff Zum arabischen Alexanderroman siehe Toufic Fahd La version arabe du Roman dAlexandre In Graeco-Arabica <num> <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num> Michel M Mazzaoui Alexander the Great and the Arab Historians In Graeco-Arabica <num> <num> S <num>-<num> Zu den spanischen Versionen der muslimischen Alexanderlegende siehe Manuela Marín Legends of Alexander the Great in Moslem Spain In Graeco-Arabica <num> <num> S <num>-<num> Richard Stoneman Alexander the Great in the Arabic Tradition In Stelios Panayotakis Hrsg The Ancient Novel and Beyond Leiden <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num>-<num> <num> Richard Stoneman Alexander the Great A Life in Legend New Haven <num> S <num>-<num> Noch im <num> Jahrhundert war diese Sichtweise bei den Parsen in Indien verbreitet siehe Friedrich Pfister Kleine Schriften zum Alexanderroman Meisenheim <num> S <num> Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> f Von einem Vordringen Alexanders nach China hatte schon der <num> gestorbene persische Gelehrte al-Bīrūnī geschrieben siehe Alexander Demandt Alexander im Islam In Monika Schuol u a Hrsg Grenzüberschreitungen Stuttgart <num> S <num>-<num> hier <num> Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Zu Nezāmis Epos siehe auch Johann C Bürgel Krieg und Frieden im Alexanderepos Nizamis In Margaret Bridges Johann Ch Bürgel Hrsg The Problematics of Power Eastern and Western Representations of Alexander the Great Bern <num> S <num>-<num> David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num> <num> <num> <num> f Zur jüdischen Alexanderlegende siehe auch Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num>-<num> Friedrich Pfister Kleine Schriften zum Alexanderroman Meisenheim <num> S <num>-<num> David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num> Arthur Hübner Alexander der Große in der deutschen Dichtung des Mittelalters In Die Antike <num> <num> S <num> Florens Deuchler Heldenkult im Mittelalter In Margaret Bridges Johann Ch Bürgel Hrsg The Problematics of Power Eastern and Western Representations of Alexander the Great Bern <num> S <num> f Georg Veloudis Alexander der Große Ein alter Neugrieche München <num> S <num> f Eine ausführlichere Darstellung bietet die Dissertation von Georg Veloudis Der neugriechische Alexander München <num>
Über die Positionen mazedonischer Nationalisten informiert Loring M Danforth The Macedonian Conflict Ethnic Nationalism in a Transnational World Princeton <num> S <num>-<num> speziell zu Alexander dem Großen S <num>-<num> Sinisa-Jakov Marusic
<num> Mai <num> Hajrudin Somun
<num> Juni <num>
Über die Positionen griechischer Nationalisten informiert Loring M Danforth The Macedonian Conflict Ethnic Nationalism in a Transnational World Princeton <num> S <num>-<num> speziell zu Alexander dem Großen S <num> <num>-<num>
DerStandardat <num> Februar <num> Abgerufen am <num> Februar <num> Gisbert Haefs Alexander Band <num> Hellas Der Roman der Einigung Griechenlands <num> und Band <num> Asien Der Roman der Eroberung eines Weltreichs <num> Valerio Massimo Manfredi Alexander Der makedonische Prinz erster Band einer Trilogie Alexander König von Asien zweiter Band und Alexander Der Herrscher der Welt dritter Band die italienische Originalausgabe aller drei Bände erschien <num> Der von Ernst Badian verfasste Alexander-Artikel im Neuen Pauly einem maßgeblichen Nachschlagewerk Bd <num> Sp <num>-<num> fasst die aus der Sicht dieser Forschungsrichtung wesentlichen Gesichtspunkte zusammen Waldemar Heckel The Conquests of Alexander the Great Cambridge <num> S IXf Frank Holt Alexander the Great today In the Interests of Historical Accuracy In The Ancient History Bulletin <num> <num> S <num>-<num> Vgl dazu Ian Worthingtons Antwort auf Holt
Antike von
alt altertümlich altehrwürdig bezeichnet eine Epoche im Mittelmeerraum die etwa von <num> v Chr
bis ca <num> n Chr
reicht wobei der Beginn teilweise noch deutlich früher angesetzt wird
Die Antike unterscheidet sich von vorhergehenden und nachfolgenden Epochen durch gemeinsame und durchgängige kulturelle Traditionen
Sie umfasst die Geschichte des antiken Griechenlands des Hellenismus und des Römischen Reichs
Insbesondere das Römische Reich vereinte den Mittelmeerraum seit dem <num> Jahrhundert n Chr
politisch und kulturell
In einem erweiterten Sinne umfasst die Antike auch die Geschichte der altorientalischen nahöstlichen Hochkulturen Ägyptens Mesopotamiens Assyriens Persiens und Kleinasiens die etwa mit dem Beginn der Schriftlichkeit um <num> v Chr einsetzt
Der größere Zeitraum von etwa <num> v Chr
bis zum Ende der Antike wird bevorzugt als Altertum bezeichnet
Die darauffolgende Epoche ist das Mittelalter mit einem breiten regional unterschiedlichen Übergangszeitraum siehe Spätantike und Frühmittelalter
Zeitliche und begriffliche Abgrenzungen
Im Sinne der klassischen Altertumswissenschaften bezeichnet der historische Begriff Antike meist die Zeit von der allmählichen Herausbildung der griechischen Staatenwelt bis zum Ende des weströmischen Reichs im Jahr <num> bzw bis zum Tod des oströmischen Kaisers Justinian <num>
Seit den Arbeiten des belgischen Historikers Henri Pirenne wird oft auch das Jahr <num> also der Tod Mohammeds und die darauf folgende islamische Expansion als Datum für das Ende der Antike vorgeschlagen
Der Anfang der antiken griechisch-römischen Kultur im klassischen Sinne wird im Allgemeinen mit der Entstehungszeit der Homerischen Epen und dem Beginn der griechischen Kolonisation des Mittelmeerraums im <num> Jahrhundert v Chr angesetzt
Die Griechen verbreiteten ihre Kultur in den folgenden Jahrhunderten im gesamten Mittelmeerraum und an den Küsten seiner Nebenmeere und seit Alexander dem Großen auch im Orient und nach Zentralasien hinein
Die Römer brachten die antike Zivilisation bis nach Mittel- und Nordwesteuropa wo sie sich seit dem Frühmittelalter zur christlich-abendländischen Kultur wandelte
Je nach Forschungsrichtung werden aber auch die minoische und mykenische Kultur von etwa <num> bis <num> v Chr sowie die so genannten Dunklen Jahrhunderte <num> bis <num> v Chr zur Antike gerechnet
Auch zwischen Antike Völkerwanderung und Mittelalter lässt sich - wie bei allen Periodisierungen in der Geschichtswissenschaft - keine für alle Regionen staatlichen und kulturellen Traditionen gültige Trennlinie ziehen
Je nach Betrachtungsweise sind unter anderem folgende Jahre als Epochengrenzen zwischen der Spätantike und Frühmittelalter vorgeschlagen worden
<num> Konzil von Nikaia
<num> Letzte Olympische Spiele der Antike
<num> Teilung des römischen Reiches nach dem Tod des Theodosius
<num> Untergang des weströmischen Reichs unter Romulus Augustulus
<num> Taufe des Frankenkönigs Chlodwig I
<num> Gründung des ersten abendländischen Benediktinerklosters und Schließung der platonischen Akademie nach dem Tod des letzten antiken Philosophen Boëthius <num>
<num> Tod Kaiser Justinians
<num> Ende der so genannten Völkerwanderung mit dem Langobardeneinfall in Italien
<num> Beginn der islamischen Expansion
<num> Tod des Kaisers Herakleios
In der neueren Forschung wird meistens ein später Zeitpunkt favorisiert <num> bzw die Zeit um <num> n Chr Generell erscheint es ohnehin sinnvoll von einem Übergangszeitraum ab ca <num> bis <num> Jahrhundert n Chr auszugehen anstatt feste Daten zu wählen
Der Begriff Antike wurde lange Zeit räumlich mit der griechischen hellenistischen und später römischen Welt gleichgesetzt
In diesem Sinne wurde der griechisch-römische Kulturraum von den umgebenden Räumen so abgegrenzt wie schon antike griechische und später römische Gelehrte sich von den Regionen der Barbaren abgrenzten siehe auch Barbaricum
Griechen wie Römer betrachteten etwa die Kelten Germanen oder Reitervölker nicht als Teil der zivilisierten Welt
Eine Sonderrolle spielte das Perserreich siehe Achämenidenreich Partherreich und Sassanidenreich das kulturell hoch entwickelt war
Über die recht enge Definition der römisch-griechischen Welt die durch die Klassische Altertumswissenschaft geprägt wurde geht der universalhistorische Antike-Begriff hinaus der unter anderem von dem Historiker Eduard Meyer im <num> Jahrhundert gefordert wurde
In jüngerer Zeit wurde er von dem deutschen Althistoriker Josef Wiesehöfer wieder aufgegriffen
Die Mehrheit der heutigen Forscher ordnet jedoch den Alten Orient und das alte Ägypten zwar dem Altertum nicht aber der Antike zu
Ursprünge der antiken Kultur
Die Ursprünge der europäischen Antike liegen im Dunkeln
Ihre Vorgeschichte ist etwa in der Zeit von ca <num> bis ca <num> v Chr im Mittelhelladikum anzusiedeln
Zu Beginn dieses Zeitabschnitts - teils auch schon im letzten Abschnitt des Frühhelladikums FH III ca <num>-<num> v Chr - wanderten wahrscheinlich indogermanische Stämme von Norden kommend in Griechenland ein
Offenbar unter dem Einfluss der minoischen Kultur auf Kreta der ersten Hochkultur Europas die ihre Blüte von ca <num> bis <num> v Chr hatte entwickelte sich auf dem Festland aus der Kultur des Mittelhelladikums die mykenische Kultur ca <num> bis <num><num> v Chr Sie hatte ihren Ausgangspunkt vermutlich in der Argolis und erscheint unvermittelt mit reichen Schachtgräbern ab ca <num> v Chr Unter anderem übernahm die mykenische Kultur von der minoischen die Schrift
Die auf Kreta unter anderem verwendete sog Linear A-Schrift des <num> bis <num> Jahrhunderts v Chr wurde zur sog Linear B-Schrift <num> bis <num> Jahrhundert v Chr weiterentwickelt
Dieser begegnet man auf zahlreichen Tontäfelchen unter anderem der Paläste in Pylos Theben Mykene auf dem griechischen Festland und in den zu jener Zeit mittlerweile mykenisch beherrschten Zentren Kydonia und Knossos auf Kreta
DateiLöwentor Mykenejpg Bekannt sind die prächtigen Zentren der mykenischen Kultur
Zu den bedeutenden Fundorten gehören Mykene Pylos und Tiryns auf der Halbinsel Peloponnes Orchomenos und Gla letzteres kein Palastzentrum in Boiotien sowie das stark mykenisch geprägte Milet in Westkleinasien
Die Zentren hatten Oberstädte Akropolen Burgen genannt die im <num> Jahrhundert v Chr in einigen Fällen stark befestigt bzw deren Befestigungen stark ausgebaut wurden Mykene Tiryns Athen
Reiche Kuppelgräber feine teils reich bemalte Keramik kunstvolle Gold- Silber- und Fayence-Arbeiten usw zeugen vom Reichtum und von der Spezialisierung des Wirtschaftssystems das in Teilen Griechenlands ab ca <num> v Chr von mächtigen Palastzenten die größere Regionen beherrschten zentral gesteuert wurde so in Böotien Attika Messenien und in der Argolis s dazu auch Mykenische Palastzeit
Intensive Handelskontakte wurden mit dem Nahen Osten Assyrien und Ägypten gepflegt
Mykenische Keramik war in weiten Teilen des Mittelmeergebiets beliebt möglicherweise ließen sich in manchen Siedlungen Süditaliens Roca Vecchia Punta Meliso Scoglio del Tonno sogar Handwerker nieder
Etwa für den Zeitraum <num> bis <num> v Chr setzt man traditionell das
Dunkle Zeitalter
an aus dem vergleichsweise wenig überliefert ist
Zu Beginn dieser Phase wurden viele der Zentren des griechischen Festlands zerstört womit die Grundlage der Palastkultur unterging
Die mykenische Kultur bestand jedoch noch etwa <num> Jahre weiter erlebte in einigen Regionen ab Mitte des <num> Jahrhunderts sogar eine gewisse Nachblüte bevor der Übergang in die sogenannte Protogeometrische Periode ca <num><num>-<num> v Chr erfolgte
Ungefähr zur gleichen Zeit als sich um <num> v Chr in Griechenland - und auch an anderen Regionen des östlichen Mittelmeerraums s auch Ende des Hethiterreichs Seevölker - Zerstörungen und Umwälzungen ereigneten entstanden auf Zypern und einigen Orten Südkleinasiens z B Tarsus und Mersin mykenisch geprägte Siedlungen
Westhandel speziell mit Italien und Sardinien wurde auch im <num> Jahrhundert v Chr weiterhin betrieben teilweise auch noch im <num> Jahrhundert v Chr Der Überlieferung nach setzte ca <num> v Chr die sehr umstrittene
Ionische Wanderung
ein in deren Verlauf die Einwohner des griechischen Festlandes die Inseln der Ägäis und die Westküste Kleinasiens kolonisierten
Auf dem griechischen Festland bietet sich ein diffuses Bild Wenige Siedlungen wurden bisher entdeckt und die meisten machen einen - im Vergleich zur mykenischen Zeit - ärmlichen Eindruck
Ganz anders hingegen Lefkandi auf Euböa dort wurden neben einer Siedlung mit einem großen Gebäude des Fürsten von Lefkandi Gräber gefunden die sehr reich ausgestattet waren
Das Dunkle Zeitalter hellt sich in den letzten Jahrzehnten - dank vieler neuer Funde vor allem aber nicht nur aus der mykenischen Spätphase des <num><num>
Jahrhunderts v Chr - immer mehr auf
Nach Annahme der Homer-Forschung spiegeln unterschiedliche Passagen der Ilias die Verhältnisse dieser Zeit wider
Sie war offenbar auch für die Entwicklung der griechischen Gesellschaft zur Polis hin wichtig
Ab dem <num> Jahrhundert waren die Kontakte zum Vorderen Orient wieder sehr intensiv und es entstanden Handelsstationen auf Zypern Kition und in Syrien Al Mina
Vermutlich bereits im späten <num> Jahrhundert v Chr hat man von den Phöniziern das Alphabet vermittelt bekommen
Griechenland und die hellenische Welt
Anfänge des klassischen Griechenlands
Mit dem so genannten archaischen Zeitalter begann im frühen <num> Jahrhundert v Chr die eigentliche Antike
Seit dem Jahr <num> v Chr ist die Siegerliste der Olympischen Spiele überliefert
Von etwa <num> bis <num> v Chr breiteten sich die Griechen während der Großen Kolonisation im westlichen Mittelmeer vor allem Sizilien und Unteritalien siehe auch Magna Graecia und bis Marseille an der nördlichen Ägäis und am Schwarzen Meer aus
In Kleinasien waren Griechen bereits vorher ansässig
In dieser Zeit etwa zwischen <num> und <num> v Chr wurden vermutlich auch die Homerischen Epen
Ilias
und
Odyssee
schriftlich fixiert die ältesten Literaturdenkmäler des Abendlands
Die ältesten tatsächlich erhaltenen Papyrusfragmente dieser Texte stammen aus dem <num> Jahrhundert v Chr die ältesten Codices mit längeren Textpassagen tauchen im Mittelalter ca <num> Jahrhundert n Chr auf wie generell der Großteil der erhaltenen antiken Literatur vor allem in mittelalterlichen Handschriften überliefert ist
Hesiod wirkte ebenfalls etwa in der Zeit um <num> v Chr
Entstehung der Polis
Die klassische Periode war eine Zeit großer kultureller und wissenschaftlicher Entfaltung
Zugleich bildete sich das System der griechischen Stadtstaaten der Poleis heraus wobei diese in der Mehrzahl nur eine sehr kleine Bevölkerung umfassten
Der werdende Militärstaat Sparta im Süden der Peloponnes unterwarf zwischen <num> und <num> v Chr Messenien und kontrollierte damit den gesamten südwestlichen Teil der Halbinsel
Die Stadt mit ihrer oligarchischen Verfassung kann als das erste Beispiel für die fortan herrschende Polis-Struktur gelten
Auch in vielen anderen griechischen Stadtstaaten regelten Verfassungen das Zusammenleben der Bürger aber auch die Tyrannis wie sie um <num> v Chr beispielsweise in Korinth und Megara bestand war keine Seltenheit
In Athen bildete sich unter wechselnden Voraussetzungen schließlich ein demokratisches System heraus
Nach den Gesetzgebungen Drakons <num> v Chr und Solons <num><num> v Chr gelang es Peisistratos und seinen Söhnen etwa zwischen <num> und <num> v Chr zwar noch einmal eine Tyrannis zu errichten
Bis <num> v Chr brachten die Reformen des Kleisthenes von Athen aber den Durchbruch für die Attische Demokratie
Blütezeit Athens
Mit Athens Unterstützung der kleinasiatischen Griechenstädte im Ionischen Aufstand um <num> v Chr begann ein annähernd zweihundertjähriger Konflikt mit dem Perserreich zunächst in Gestalt der drei Perserkriege die der Historiker Herodot der Vater der Geschichtsschreibung mit ihm lässt man traditionell die griechische Geschichtsschreibung beginnen vgl
Liste der griechischsprachigen Geschichtsschreiber der Antike
in seinen Historien geschildert hat wenngleich nicht immer zuverlässig
Als die Perser zu einer Strafexpedition in Griechenland einfielen wurden sie <num> v Chr von den Athenern in der Schlacht bei Marathon besiegt
Zehn Jahre später unterlag der persische Großkönig Xerxes I der athenischen Flotte unter Themistokles in der Schlacht von Salamis und <num> v Chr den vereinigten Heeren der griechischen Poleis in der Schlacht von Plataiai
Die Perser waren vorerst zurückgedrängt die griechischen Stadtstaaten in Kleinasien aus der Abhängigkeit befreit
DateiAthens Acropolisjpg Nach der erfolgreichen Verteidigung und mit der Gründung des Attischen Seebunds <num> v Chr unter der auf die eigene Seemacht gestützte Vorherrschaft Athens setzte eine etwa <num>-jährige Blütezeit der Stadt die Pentekontaetie ein die bis zum Ausbruch des Peloponnesischen Krieges <num> v Chr bzw bis zum Tod des leitenden Staatsmannes Perikles im Jahr <num> v Chr reichte
Die Akropolis mit dem Parthenontempel wurde damals unter der Regie des Phidias zum glanzvoll-repräsentativen Zentrum der Seemacht Athen ausgebaut
Die klassischen Tragödien von Aischylos Sophokles und Euripides kamen - meist im Rahmen festlicher Dichterwettbewerbe - im Theater zur Aufführung
Kaufleute und Gewerbetreibende Künstler und Gelehrte zog die Metropole an
Auf der Agora wirkte neben den Sophisten der Philosoph Sokrates auf seine Mitbürger ein dessen Lehren Platon später zu einem Werk von herausragender philosophiegeschichtlicher Bedeutung verarbeitete
Athen mit seinen zu gleichberechtigter politischer Mitwirkung gelangten männlichen Vollbürgern beanspruchte nunmehr die Schule von Hellas zu sein
Seine durchaus auch aggressive äußere Machtentfaltung in und mit dem Attischen Seebund führte allerdings schon während der Pentekontaetie zu Spannungen vor allem gegenüber der konkurrierenden griechischen Großmacht Sparta
Kampf um die Hegemonie
Die zunehmende Rivalität zwischen der Seemacht Athen und der Landmacht Sparta mündete <num> v Chr in den fast <num> Jahre währenden Peloponnesischen Krieg den die zeitgenössischen Historiker Thukydides und im Anschluss an Thukydides Xenophon eindringlich beschrieben haben
Der sehr wechselhaft verlaufende und mit einer als beispiellos empfundenen Brutalität geführte Konflikt endete auch auf Grund der Unterstützung Spartas durch das Perserreich <num> v Chr mit der vollständigen Niederlage Athens und mit der Errichtung einer zeitweiligen spartanischen Hegemonie über Griechenland
In der ersten Hälfte des <num> Jahrhunderts v Chr führten die griechischen Städte einen fast permanenten Krieg gegeneinander und in wechselnden Koalitionen auch unter fortwährender Einmischung der Perserkönige
Die Sehnsucht nach einem Allgemeinen Frieden wurde auch zu propagandistischen Zwecken eingesetzt Königsfrieden von <num> v Chr <num> v Chr löst Theben unter Epaminondas nach der Schlacht bei Leuktra Sparta als Hegemon ab
Doch auch Thebens Vorherrschaft bestand nur bis rund <num> v Chr und endete mit dem Tod Epaminondas
Insgesamt schwächte der Peloponnesische Krieg die griechischen Polis so stark dass Philipp II von Makedonien dem andauernden Machtkampf ein Ende setzen konnte indem er Griechenland gewaltsam mit seinem hervorragend geschulten Heer einigte
Der von Athenern wie Demosthenes als nicht-griechischer Barbar betrachtete König errang mit seinem geschulten Heer in der Schlacht von Chaironeia <num> v Chr die Hegemonie über Hellas die im Jahr darauf im Korinthischen Bund bekräftigt wurde
Auf Sizilien behauptete sich derweil das mächtige Syrakus gegenüber der Handelsrepublik Karthago welche mit den griechischen Poleis Westgriechen seit dem frühen <num> Jahrhundert v Chr im Konflikt lag
Auf Sizilien hielt sich zudem im Gegensatz zum Mutterland in vielen Städten die Tyrannis als Regierungsform Dionysios I von Syrakus Agathokles von Syrakus und andere
Hellenistische Zeit <num> bis <num> v Chr
DateiAlexanderTheGreat Bustjpg Nach der Ermordung Philipps <num> v Chr führte sein Sohn Alexander der Große ein griechisch-makedonisches Heer nach Asien und eroberte in wenigen Jahren mit dem Perserreich ein Weltreich
Der Alexanderzug bahnte der griechischen Kultur im ganzen damals bekannten Orient den Weg von Ägypten über Mesopotamien und Persien bis zu den Grenzen Indiens und Turkestans
Nach Alexanders Tod <num> v Chr in Babylon teilten seine Nachfolger die Diadochen in lange währenden Kriegen das Reich unter sich auf
In allen Teilreichen bildete der Hellenismus in den folgenden Jahrhunderten die prägende Kultur
Das Zeitalter des Hellenismus kennzeichnet ein nahezu ständiger Kampf der drei Großmächte Ptolemäer Seleukiden und Antigoniden um die Vorherrschaft
Dennoch wuchs die Bevölkerung im gesamten Mittelmeerraum stetig und ermöglichte so das Wachstum größerer Städte und Metropolen mit Einwohnern über <num> Menschen
Auch breitete sich in dieser Zeit der Fernhandel bis hin nach China und die Güterproduktion für große städtische Märkte aus Verschiedene Wissenschaften blühten auf bspw in Alexandria
Zu Beginn des <num> Jahrhunderts v Chr tauchte erstmals Rom als bedeutende Macht in Griechenland auf und dehnte nach und nach seinen Einfluss aus
<num> v Chr unterstellte das Römische Reich die Mitglieder des unterlegenen Achaiischen Bundes der Provinz Macedonia Korinth als führende Polis wurde zerstört
Doch blieben viele Poleis wie Athen und Sparta zumindest vorerst formell unabhängig
Bald darauf folgte der Erwerb Pergamons durch Rom und <num><num> v Chr die Beseitigung der Überreste des Seleukidenreiches
Als letzter Nachfolgestaat des Alexanderreichs wurde im Jahre <num> v Chr das ptolemäische Ägypten dessen letzte Herrscherin Kleopatra VII war ins Römische Reich eingegliedert
Damit war die hellenistische Staatenwelt als machtpolitischer Faktor ausgelöscht
Die griechische Kultur lebte jedoch im Römischen Reich sowie später im Byzantinischen Reich fort
Römisches Reich
Nach den Griechen wurden die Römer zu den zweiten Trägern und Vermittlern der antiken Kultur und prägten diese für mehrere hundert Jahre
Je weiter sie als Eroberer in außeritalische Länder vordrangen desto stärker ließen sie sich von deren Kultur inspirieren und beeinflussen
Sie adaptierten teilweise lokale Gebräuche
Literatur Philosophie Kunst Architektur und Alltagskultur der Griechen und der Länder der Levante Waffentechniken der Gallier oder Germanen und religiöse Einflüsse aus Ägypten wurden von den Römern aufgenommen
Nicht zuletzt durch die kulturelle Ausstrahlung und Heterogenität der Stadt Rom die sich in der römischen Kaiserzeit zur Millionenstadt entwickelte wurden solche Einflüsse im Imperium verbreitet
Ursprünge Roms
Rom der Legende nach <num> v Chr gegründet entstand neueren Forschungen zufolge erst gegen Ende des <num> Jahrhunderts v Chr aus dem Zusammenschluss mehrerer dörflicher Siedlungen an einer Furt am Unterlauf des Tibers
Politisch und kulturell stand Rom lange unter etruskischem Einfluss
Die Etrusker wiederum unterhielten schon früh Kontakt mit griechischen Kolonisten
Römische Republik ca <num> bis <num> v Chr
DateiCt-fororomano<num>jpg Um <num> v Chr befreiten sich die Römer vom etruskischen Stadtkönigtum und bildeten wohl um <num> v Chr eine republikanische Regierungsform aus
In den Zwölftafelgesetzen die um <num> v Chr entstanden wurden die ersten zivil- straf- und prozessrechtlichen Normen des römischen Rechts festgehalten
Die Verfassung sah von da an ein Zusammenwirken der drei Institutionen Senat Magistratur und Volksversammlung vor die sich in ihrer Macht theoretisch gegenseitig beschränkten
Die offizielle Bezeichnung der Republik lautete SPQR für Senatus Populusque Romanus dt Senat und Volk von Rom
Machtpolitisch dominierte der Senat der sich aus Angehörigen der adligen Familien der Patrizier zusammensetzte und später der plebejischen Patrizier
Aus ihm gingen auch die Konsuln hervor die beiden auf ein Jahr gewählten obersten Magistrate der Republik
Das zunächst höchste den nichtadeligen Plebejern zugängliche Amt war das des Volkstribunen der ein Vetorecht gegen Senatsbeschlüsse besaß
DateiGaius Julius Caesar <num>-<num> BCJPG Mit der Legion entwickelten die Römer eine effektive Streitmacht
Bis zum Jahr <num> v Chr unterwarfen sie ganz Italien südlich der Poebene
Mit den Punischen Kriegen gegen die Seemacht Karthago im <num> und <num> Jahrhundert v Chr begann der Aufstieg Roms zur antiken Weltmacht die für die folgenden Jahrhunderte die gesamte Mittelmeerwelt beherrschen sollte
Nach <num> v Chr nahm Rom zunehmend Einfluss auf die Politik der hellenistischen Großmächte und wurde zur Protektoratsmacht im östlichen Mittelmeerraum
<num> v Chr wurde das Makedonien der Antigoniden <num> v Chr das Reich der Seleukiden und schließlich <num> v Chr das Ägypten der Ptolemäer römische Provinz
Die Römische Republik ermöglichte durch die Herstellung von innerem Frieden ein weiteres kontinuierliches Bevölkerungswachstum auch durch die ständige Neugründung von Kolonien in eroberten Ländern
Durch die Ansiedlung von Veteranen aus den Legionen vorheriger Kriege konnte die Republik zudem einen verlässlichen Einfluss in diesen Ländern gewinnen und gleichzeitig mit einem stetigen Bevölkerungszuwachs neue Gebiete kultivieren
Handel und Verkehr konnten auch dank der Römerstraßen zunehmen welche zunächst häufig aus militärischen Gründen angelegt wurden und die wachsenden Reichsstädte und Kolonien miteinander verbanden
Entlang der Straßen entwickelten sich Streckenposten und Marktflecken zu Städten
Mit diesen infrastrukturellen Neuerungen ging im Reich ein Wachstum der wirtschaftlichen Produktion und somit auch der verfügbaren Steuermittel einher
Mit dem Wachstum der Republik an Größe Macht und Wohlstand kam es jedoch im Inneren zu einer Reihe von Krisen in denen sich der Kampf der an den überkommenen sozioökonomischen Strukturen festhaltenden Optimaten gegen die auf Reformen drängenden Popularen spiegelte
In der Epoche der Bürgerkriege erreichte die Krise der späten Römischen Republik ihren Höhepunkt und es zeichnete sich ab dass die Republik als inhaltlich gelebte Staatsform die Erfolge nicht mehr meistern konnte die sie gezeitigt hatte So wurde der Prinzipat möglich also die Umwandlung der Republik in eine Monarchie mit republikanischer Fassade
Bereits Gaius Iulius Caesar hatte als Diktator auf Lebenszeit dictator perpetuus eine quasi-monarchische Stellung erlangt
Als erster römischer Kaiser gilt jedoch sein Großneffe und Erbe Augustus dem es gelang mit dem Prinzipat eine dauerhafte monarchische Staatsordnung an die Stelle der zerrütteten Republik zu setzen wobei jedoch die entmachteten Staatsorgane der Republik z B
der Senat formal noch lange fortbestanden
Prinzipat <num> v Chr bis <num> n Chr
DateiStatue-Augustusjpg Das von Augustus errichtete Kaisertum Prinzipat wurde von ihm und seinem Nachfolger Tiberius für rund <num> Jahre sicher geführt
Augustus bewahrte noch bewusst eine republikanische Fassade während unter Tiberius das Kaisertum zur Normalität wurde
Unter Caligula Claudius und Nero traten jedoch zeitweilig Zerfallserscheinungen auf
Nach dem Krisenjahr <num><num> Vierkaiserjahr traten die Flavier Vespasian Titus Domitian die Regierung an die sowohl außen- als auch innenpolitisch insgesamt recht erfolgreich herrschten
Nach der Ermordung Domitians der <num> einer Verschwörung zum Opfer fiel folgte eine weitere kurze Krise des Herrschaftssystems die jedoch unter den so genannten Adoptivkaisern weitgehend behoben werden konnte
Das Imperium erlebte seine größte Blüte und Ausdehnung dann auch unter ebendiesen Adoptivkaisern das Kaisertum war auch weiterhin formal nicht erblich in der ersten Hälfte des <num> Jahrhunderts Einer Expansion unter Trajan vor allem im Balkanraum und im Osten gegen das Partherreich folgte eine Rücknahme und Sicherung der Grenzen unter Hadrian
Bald nach der Mitte des <num> Jahrhunderts n Chr wuchs jedoch der Druck auf die ausgedehnten Reichsgrenzen
Im Norden und Nordosten bedrängten die Germanen im Osten die Parther die sich trotz mancher Niederlage behaupten konnten das Reich
Mark Aurel der Philosophenkaiser im Geiste der Stoa sah sich bald nach Übernahme der Herrschaft nahezu ständig zur kriegerischen Verteidigung der Reichsgrenzen genötigt
Mit seinem Tod endete <num> n Chr ein als Blütezeit betrachtetes Zeitalter des Imperiums
Nach dem schwachen Commodus der <num> ermordet wurde stabilisierten die Kaiser aus dem Hause der Severer hervorzuheben ist besonders Septimius Severus die Grenzen wenigstens teilweise
Kaiser Caracalla gewährte <num> mit der Constitutio Antoniniana allen freien Reichsbürgern das Bürgerrecht
Nach der Ermordung des Severus Alexander <num> kam es jedoch unter den so genannten Soldatenkaisern zur Reichskrise des <num> Jahrhunderts die aber erst um <num> ihren Höhepunkt erreichte
Dieser Zeitraum war geprägt von raschen Regierungswechseln zeitweiligen und regional unterschiedlichen ökonomischen Problemen zentrifugalen Tendenzen im Inneren zeitweilige Abspaltung des
Imperium Galliarum
Verlust mehrerer Provinzen an Palmyra und dem stetig wachsenden Druck auf die Grenzen
Neben den verschiedenen Germanenstämmen wie den Alamannen und Goten übte nun vor allem das Sassanidenreich im Osten einen enormen Druck aus Nach dem Sturz des letzten Partherkönigs im Jahr <num> bzw <num> erneuerten die Sassaniden das Perserreich und erwiesen sich in der Regel als den Römern gleichwertige Gegner wenngleich auch sie mit einer gefährdeten Grenze konfrontiert waren im spätantiken Zentralasien siehe Iranische Hunnen
Die Zeit der Soldatenkaiser wird allerdings in der neueren Forschung keineswegs mehr als eine reine Krisenzeit begriffen sondern vielmehr als eine wenngleich teils von Krisensymptomen begleiteten Transformationsphase
Spätantike <num> bis <num><num> n Chr
Mit der Einführung der Tetrarchie <num> und zahlreichen inneren Reformen gelang es Kaiser Diokletian seit <num> Kaiser gegen Ende des <num> Jahrhunderts noch einmal das Reich zu stabilisieren
Diese Zeit der beginnenden Spätantike ist gekennzeichnet von Umbrüchen die zum Teil eine Abkehr von bis dahin wesentlichen Bestandteilen der antiken Kultur darstellten
Dazu gehört vor allem die von Kaiser Konstantin I initiierte Anerkennung und Privilegierung des Christentums das unter Diokletian noch verfolgt worden war
Die Hinwendung zu dem neuen Glauben ging schließlich mit der Ablehnung des religiösen Pluralismus der Antike einher
Ein letzter Versuch die alten Kulte durch die Verbindung mit neuplatonischem Gedankengut wieder zu beleben scheiterte mit dem Tod Kaiser Julians im Jahr <num> alle nachfolgenden Kaiser waren Christen
Teilweise stießen auch bestimmte Formen der Philosophie auf Ablehnung wenngleich das Christentum nun selbst stark von der griechischen Philosophie geprägt wurde und zwischen <num> und <num> eine massive Transformation durchlief bspw mit dem Ersten Konzil von Nicäa
Die Platonische Akademie in Athen oft als Hort des Heidentums bezeichnet wurde <num> geschlossen während die bereits christianisierte Schule von Alexandria noch bis zum Beginn des <num> Jahrhunderts bestehen blieb
Kaiser Valentinian I festigte den Westen des Reiches doch kam es <num> unter seinem Bruder Valens zur Niederlage von Adrianopel und zu einer neuen Krise
In diesem Zusammenhang gehört das Auftauchen der Hunnen nur eines von zahlreichen Reitervölkern aus der eurasischen Steppenzone die teils eine wichtige Rolle spielten und der Beginn der sogenannten Völkerwanderung
Kaiser Theodosius I wiederum konnte den Osten des Reiches stabilisieren und war zugleich der letzte Kaiser der de facto über das gesamte Imperium Romanum herrschte
Er erklärte das Christentum schließlich <num> zur Staatsreligion und verbot alle heidnischen Kulte wie die Olympischen Spiele
Allerdings lassen sich noch bis mindestens in das <num> Jahrhundert hinein bedeutende heidnische Minderheiten auf dem Boden des Imperiums nachweisen
DateiJustinian mosaik ravennajpg Nach der faktisch endgültigen Teilung des Reiches unter den beiden Söhnen des Theodosius <num> erwies sich letztlich nur das von Konstantinopel dem früheren Byzantion aus regierte Oströmische Reich auf die Dauer eines weiteren Jahrtausends als lebensfähig
Es bewahrte viele antike Traditionen unter anderem blieb das Lateinische in dem überwiegend griechischsprachigen Reich noch bis ins <num> Jahrhundert Amtssprache
Das so genannte Weströmische Reich hingegen zerbrach aufgrund endloser innerer Kriege gepaart mit äußerem Druck siehe Völkerwanderung
Germanische Kriegerverbände traten an die Stelle der kollabierenden Reichsregierung und ergriffen zunächst als
foederati
seit dem <num> Jahrhundert direkt Besitz von weströmischen Provinzen
Ihre Anführer traten hier oft an die Stelle der römischen Autoritäten
Rom selbst wurde <num> von den Westgoten und <num> von den Vandalen geplündert von der Millionenstadt der hohen Kaiserzeit schrumpfte sie auf schätzungsweise <num> Einwohner zum Ende des <num> Jahrhunderts
Die Spätantike sah auch das langsame Verschwinden der klassisch-antiken Stadt
polis
bzw
civitas
In der Forschung ist umstritten ob es sich hierbei um einen Niedergang oder eher um einen Wandel handelt - diese Frage stellt sich auch für viele andere Aspekte der Epoche z B
im wirtschaftlichen Bereich wobei viele Provinzen weiterhin aufblühten
Im Westen das Ostreich war davon nicht betroffen und durchlief erst im <num> Jahrhundert eine Krisenzeit siehe unten lösten sich im <num> Jahrhundert zunehmend die politischen Strukturen auf während das reguläre Heer zumindest nach Ansicht der älteren Forschung immer stärker barbarisiert wurde und die Bedeutung der nichtrömischen
foederati
besonders im Westen immer mehr zunahm
Die geringer werdenden Steuereinnahmen durch den Verlust von Provinzen und Steuermitteln führten dazu dass die Regierung in Ravenna immer hilfloser wurde die kaiserliche Autorität schwand dahin während die eigentliche Macht nun meist bei hohen Militärs wie Aetius oder Ricimer lag die gegeneinander oft blutige Bürgerkriege führten und das Westreich so weiter schwächten
<num> setzte der General Odoaker der Kommandeur der föderierten Truppen in Italien dann den letzten Westkaiser Romulus Augustulus ab da dieser überflüssig geworden sei und unterstellte sich der nominellen Oberherrschaft des oströmischen Kaisers
Die Geschichtswissenschaft sah in diesem von den Zeitgenossen nur wenig beachteten Akt früher oft das Ende der Antike
Heute wird dagegen auch das <num> Jahrhundert noch zur Antike gezählt da vor allem im Osten römisch-antike Strukturen fortbestanden und dem oströmischen Kaiser Justinian <num>-<num> für kurze Zeit noch einmal eine Rückeroberung großer Teile des Westreiches gelang
Dass diese letztlich dennoch scheiterte hatte auch mit dem Druck zu tun den die Sassaniden seit <num> erneut auf die Ostgrenze des Reiches ausübten siehe auch Römisch-Persische Kriege und Herakleios
Im Oströmischen Reich lebten antike Kultur und Geisteswelt zwar noch bis weit ins Mittelalter fort
Die islamische Expansion des <num> Jahrhunderts führte allerdings auch hier zu erheblichen Veränderungen und gilt als der entscheidende Einschnitt der das Ostrom der Spätantike vom Byzantinischen Reich des Mittelalters trennt
Bedeutung und Nachwirken der Antike
Antike Traditionen hatten starke und prägende Auswirkungen auf den weiteren Verlauf der Weltgeschichte insbesondere auf die Entwicklung der westlichen Welt die in der Antike ihre Wurzeln hat
Neuzeitliche Aufklärer Philosophen Staatstheoretiker Wissenschaftler Künstler und andere knüpften immer wieder an die Ionische Naturphilosophie die attische Demokratie das römische Recht den religiösen Pluralismus das antike Schönheitsideal und andere Hinterlassenschaften der Antike an
Antike Traditionen gerieten auch im Mittelalter nie völlig in Vergessenheit
In den Klöstern des Abendlandes wurde umfangreiches antikes Schriftgut bewahrt
Auch die Romidee blieb im Heiligen Römischen Reich lebendig
Im <num> Jahrhundert kam es zur ersten sogenannten Karolingischen Renaissance
Auch byzantinische und arabische Gelehrte stützten sich auf antikes Wissen und gaben es indirekt an das mittelalterliche Europa weiter
Als man im Italien des <num> Jahrhunderts die - meist römischen - Überreste der Antike neu zu schätzen lernte und in der Kunst nachahmte bezeichnete man dies als
Renaissance
Die Wiedergeburt der Antike und des antiken Geistes setzte der jahrhundertelangen Dominanz religiösen Denkens in Europa ein Ende und mündete schließlich in das Zeitalter der europäischen Aufklärung und in die Moderne
Fast alle Ideen der neuzeitlichen Aufklärung haben antike Vorläufer
Ohne griechische Wissenschaft und Philosophie ohne die damals entstandenen politischen Ideen ohne das römische Recht ohne Architektur und Kunst der Griechen und Römer ist die westliche Kultur der Neuzeit nicht denkbar
So trat infolge der Arbeiten von Johann Joachim Winckelmann seit dem <num> Jahrhundert die klassische griechische Kunst - oder vielmehr das was man idealisierend für diese hielt - zunehmend ins Zentrum des Interesses
Im <num> Jahrhundert sprach man im Zusammenhang mit den Arbeiten von Architekten und Künstlern wie Karl Friedrich Schinkel Leo von Klenze und Bertel Thorvaldsen von einer Renaissance der griechischen Antike heute vom Neuhumanismus
Erst nach dem Zweiten Weltkrieg verlor die griechisch-römische Zivilisation zunehmend die Vorbildfunktion die man ihr in Europa und Nordamerika jahrhundertelang zugesprochen hatte
Ein entscheidender Einschnitt war hier das Verschwinden des griechischen und stark auch des lateinischen Unterrichtsfaches von den Sekundarschulen
Ein weiterer Aspekt war dass in der ersten Hälfte des <num> Jahrhunderts Elemente der antiken Tradition von Anhängern totalitärer Ideologien willkürlich aufgegriffen und so zweckentfremdet wurden
Der Führerkult des faschistischen Regimes in Italien griff direkt auf das antike Rom zurück und knüpfte nach dem Verständnis des Regimes an den Caesarenkult an wobei bereits der Terminus fascismo vom lateinischen Begriff
fasces
abgeleitet ist
Benito Mussolini wurde als Nachfolger des Augustus in eine Reihe mit den römischen Caesaren gestellt und es wurde eine Wiedererrichtung des antiken Römischen Reiches angestrebt
Auch das NS-Regime in Deutschland orientierte sich teils an antiken Vorbildern so etwa im Zusammenhang mit der ideologisch begründeten Lobpreisung Spartas
Der Bedeutungsverlust nach dem Ende des Zweiten Weltkrieges hat für die Altertumswissenschaften allerdings immerhin den Vorteil dass nun ein unverstellterer neutraler Blick auf die Antike leichter möglich ist
Bis heute erhaltene Zeugnisse der Antike sind - neben überlieferten Texten philosophischer literarischer oder historischer Natur - zahlreiche Objekte der griechischen und römischen Kunst von großen Skulpturen bis zur Kleinkunst Töpferei Münzen etc Wichtige Antikensammlungen befinden sich in Rom Athen Neapel Paris London München Sankt Petersburg Wien und Berlin
Für die Kenntnis des antiken Alltags sind vor allem archäologische Ausgrabungen wie die in Pompeji Olympia Delphi oder Pergamon von Bedeutung
Quellenlage
Der Großteil der antiken Literatur und damit auch der Geschichtsschreibung ist nicht erhalten sodass unser Wissen über die Antike durch die Überlieferungslage beeinflusst wird siehe auch Antike Geschichtsschreibung und hinsichtlich der griechischen Geschichtsschreibung die Liste der griechischsprachigen Geschichtsschreiber der Antike
Es wurde geschätzt dass uns kaum <num>
der griechischen Literatur überliefert ist Andere Forscher sind noch weit pessimistischer und gehen eher von einer Verlustrate um <num>
aus
In Teilen sieht es besonders trostlos aus Archaik Hellenismus in anderen Bereichen etwas besser klassische Zeit Griechenlands sowie Spätantike
Insgesamt ist die Quellenlage jedoch problematisch man muss in allen Bereichen davon ausgehen dass vieles spurlos verloren ist und sich auch viele Ereignisse und Zusammenhänge unserer Kenntnis entziehen
Neben den erzählenden Quellen müssen daher natürlich auch Inschriften und Papyri sowie archäologische und numismatische Quellen etc herangezogen werden
Eine Zusammenfassung mit ausführlichen Angaben bieten die jeweiligen Artikel Geschichtsschreibung u ä in den entsprechenden Lexika siehe unten
Im Folgenden seien einige der wichtigsten antiken Geschichtsschreiber und ihre oft nur teilweise erhaltenen Texte genannt
Herodot
Historien
Thukydides Der Peloponnesische Krieg
Xenophon
Hellenika
Der Zug der Zehntausend Anabasis
Polybios Historien
Diodor Bibliothek
Sallust Die Verschwörung des Catilina Der Krieg gegen Jugurtha
Caesar
Der Gallische Krieg
Der Bürgerkrieg
Livius
Römische Geschichte
Flavius Josephus Der jüdische Krieg
Tacitus
Annalen
Historien Germania
Arrian Alexanders des Großen Zug durch Asien
Sueton Leben der Caesaren
Cassius Dio Römische Geschichte
Ammianus Marcellinus Res Gestae
Anonymus
Historia Augusta
Zosimos Neue Geschichte
Prokop Kriege Bauten und Geheimgeschichte
Siehe auch die online verfügbaren Quellensammlungen wie LacusCurtius oder das Perseus Project
Siehe auch
Portal Altertum
Verschiedenes
Persische Architektur
Geschichte der Geschichtsschreibung
Rhetorik der Antike
Bücherverluste in der Spätantike
Rom
Römische Religion
Lateinische Literatur
Untergang des Römischen Reiches
Listen
Liste antiker Stätten
Liste antiker Ortsnamen und geographischer Bezeichnungen
Liste der Abkürzungen antiker Autoren und Werktitel
Quellenausgaben
Quellenausgaben mit Übersetzungen bieten neben anderen Reihen die Sammlung Tusculum und die Loeb Classical Library
Eine äußerst wichtige Sammlung der erhaltenen Reste ansonsten verlorener griechischer Geschichtsschreiber stellt der Jacoby dar
Felix Jacoby
Die Fragmente der griechischen Historiker FGrHist Weidmann Berlin <num> ff Nachdr Brill Leiden <num>ff ISBN <num>-<num>-<num>-<num> CD-ROM ISBN <num>-<num>-<num>-<num>
Siehe nun vor allem auch die Neubearbeitung mit englischer Übersetzung und neuem Kommentar
Brills New Jacoby
Die Fragmente römischer Historiker sind gesammelt in
Die frühen römischen Historiker
und in allerdings nur bis zur Mitte des <num> Jahrhunderts n Chr
The Fragments of the Roman Historians
Für die Spätantike sind die Sammlungen
Kleine und fragmentarische Historiker der Spätantike
und
Translated Texts for Historians
von Bedeutung
Literatur
Allgemein Aufgrund der Masse an Fachpublikationen kann an dieser Stelle nur eine sehr beschränkte Auswahl genannt werden
Das zentrale bibliographische Nachschlagewerk der Altertumswissenschaft stellt immer noch die
LAnnée philologique
dar LAnnée Philologique
Bibliographie critique et analytique de lAntiquité greco-latine hrsg von J Marouzeau und J Ernst Paris <num>ff Kostenlos nutzbar ist zudem die umfangreiche Gnomon-Datenbank
Ausführliche Angaben sind außerdem entweder den Bibliographien der unten genannten Werke besonders sei dabei auf The Cambridge Ancient History und Oldenbourg Grundriss der Geschichte hingewiesen zu entnehmen oder den Bibliographien die in der ausführlichen HU-Linkliste aufgeführt sind siehe beispielsweise KU Eichstätt kommentiert
Es sei außerdem auf die hier verlinkten Artikel verwiesen wo sich zahlreiche weiterführende Literaturangaben finden
Lexika
Paulys Realencyclopädie der classischen Altertumswissenschaft Pauly-Wissowa RE
Herausgegeben von Georg Wissowa und anderen in <num> Reihen Stuttgart <num>-<num> ISBN <num>-<num>-<num>-<num> Neudruck ab <num>ff trotz des Alters in seiner Gesamtheit nicht überholtes Grundlagenwerk
Konrat Ziegler Walther Sontheimer Hans Gärtner Hrsg
Der Kleine Pauly
Lexikon der Antike
KlP <num> Bände
Druckenmüller Artemis Stuttgart München <num>-<num> ISBN <num>-<num>-<num>-X Nachdruck dtv München <num> hervorragendes Lexikon auf Grundlage der RE jedoch mit verkürzten und neugeschriebenen Artikeln
Hubert Cancik Helmuth Schneider Hrsg
Der Neue Pauly
Enzyklopädie der Antike
DNP Metzler Weimar Stuttgart <num>-<num> ISBN <num>-<num>-<num>-<num> <num> Bände mit schwankender Qualität der Beiträge
S Hornblower A Spawforth Hrsg
The Oxford Classical Dictionary
OCD
<num> Auflage
Oxford University Press Oxford <num> wohl das beste einbändige Lexikon über die Antike mit teils herausragenden Artikeln
Graham Shipley u a Hrsg The Cambridge Dictionary of Classical Civilization Cambridge <num> aktuelles und gut bebildertes Nachschlagewerk zur klassischen Antike Rezension in
Carl Andresen und andere Hrsg
Lexikon der Alten Welt LAW Albatros Düsseldorf <num> ISBN <num>-<num>-<num>-<num> in viele Bereichen veralteter Forschungsstand
Oliver Nicholson Hrsg
The Oxford Dictionary of Late Antiquity Oxford University Press Oxford <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelles Fachlexikon zur Spätantike
Heinrich Beck Herbert Jankuhn Hans Kuhn Kurt Ranke Reinhard Wenskus Hrsg Johannes Hoops Begründer
Reallexikon der Germanischen Altertumskunde RGA <num> völlig neu bearbeitete und stark erweiterte Auflage
De Gruyter BerlinNew York <num>-<num> Neubearbeitung des wichtigen Lexikons von Hoops
Theodor Klauser und andere Hrsg
Reallexikon für Antike und Christentum RAC Stuttgart <num>ff ISBN <num>-<num>-<num>-<num> noch nicht abgeschlossen besonderes Augenmerk gilt der Spätantike
Kai Brodersen Bernhard Zimmermann Hrsg Metzler Lexikon Antike <num> überarbeitete und erweiterte Auflage
J B Mezler Verlag Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Dietrich Klose Hrsg Reclams Lexikon der Antike RLA aufgrund der englischen Ausgabe von Paul Harvey bzw Margaret C Howatson übersetzt von Marie-Luise Gutbrodt Dietrich Klose und Wolfgang Kiehne
Stuttgart <num>
Heinz Mikisch Basiswissen Antike
Ein Lexikon
Verlag Philipp Reclam jun Stuttgart <num> ISBN <num>-<num>-<num>-<num> sehr knapp
Einführungen
Hans-Joachim Gehrke Helmuth Schneider Hrsg Geschichte der Antike <num> erweiterte und aktualisierte Auflage
Metzler StuttgartWeimar <num> ISBN <num>-<num>-<num>-<num>-<num> grundlegende Einführung
Hans-Joachim Gehrke Hrsg Die Welt vor <num>
Frühe Zivilisationen
Geschichte der Welt Band <num>
C H Beck München <num> ISBN <num>-<num>
Rosemarie Günther Einführung in das Studium der Alten Geschichte Paderborn <num> ISBN <num>-<num>-<num>-<num>
Hartmut Leppin Einführung in die Alte Geschichte München <num> ISBN <num>-<num>-<num>-<num>
Allgemeine Darstellungen
Beck Geschichte der Antike <num> Bände
CH Beck München <num>-<num> sortiert nach Epochendarstellung die jeweiligen Bände sind gut lesbare aktuelle Einführungen in die jeweilige Epoche Elke Stein-Hölkeskamp Das archaische Griechenland
Die Stadt und das Meer
München <num>
Sebastian Schmidt-Hofner Das klassische Griechenland
Der Krieg und die Freiheit
München <num>
Peter Scholz Der Hellenismus
Der Hof und die Welt
München <num>
Wolfgang Blösel Die römische Republik
Forum und Expansion
München <num>
Armin Eich Die römische Kaiserzeit
Die Legionen und das Imperium
München <num>
Rene Pfeilschifter Die Spätantike
Der eine Gott und die vielen Herrscher
München <num>
Blackwell History of the Ancient World Blackwell Oxford u a ebenfalls empfehlenswerte aktuelle Epocheneinführungen Marc Van de Mieroop A History of the Ancient Near East ca <num>-<num> BC <num> Auflage
<num>
Jonathan Hall A History of the Archaic Greek World <num> Auflage
<num>
P J Rhodes A History of the Classical Greek World <num>
Robert Malcolm Errington A History of the Hellenistic World <num>
Stephen Mitchell A History of the Later Roman Empire AD <num>-<num> <num> Auflage
<num>
Timothy E Gregory A History of Byzantium <num> Alle Bände bieten einen gut lesbaren und fundierten knappen Überblick mit aktueller Literatur
Blackwell Companion to the Ancient World Verschiedene Herausgeber
Blackwell Oxford <num>ff
Inzwischen sind zahlreiche Bände erschienen bzw in Vorbereitung sie bieten in Form von mehreren relativ knappe Fachaufsätzen einen Einstieg auf Grundlage der aktuellen Forschungslage
The Cambridge Ancient History Div Hrsg <num> Bände teils in Teilbänden
<num> Auflage
Cambridge <num>ff
Umfassende und sehr wichtige Gesamtdarstellung der Antike
Die zweite Auflage ist vollständig neubearbeitet worden
Aloys Winterling Kai Brodersen Martin Jehne Winfried Schmitz Hrsg Enzyklopädie der griechisch-römischen Antike <num> Bände
Oldenbourg München <num>ff
Noch nicht abgeschlossene Handbuchreihe der Aufbau ist an der Enzyklopädie deutscher Geschichte orientiert
Geschichte kompakt Antike Wissenschaftlichen Buchgesellschaft Darmstadt mehrere Bände gute knappe Einführungen mit einem in die Darstellung integrierten Forschungsüberblick
Werner Dahlheim Die Antike
Griechenland und Rom von den Anfängen bis zur Expansion des Islam
Schöningh Verlag Paderborn <num> ISBN <num>-<num>-<num>-<num>
Robin Lane Fox Die klassische Welt
Eine Weltgeschichte von Homer bis Hadrian
Klett-Cotta Stuttgart <num> gut lesbare und verlässliche Überblicksdarstellung bis ins <num> Jahrhundert n Chr
Wolfgang Schuller Das Erste Europa <num> v Chr-<num> n Chr Handbuch der Geschichte Europas Band <num>
Ullmer Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Jochen Bleicken u a Hrsg
Oldenbourg Grundriss der Geschichte Band <num>-<num> München <num> ff versch
Auflagen
Dreiteilung jedes Bandes <num> sehr knappe Darstellung <num> Forschungsüberblick und <num> umfassende Bibliographie
Eckhard Wirbelauer Hrsg Oldenbourg Geschichte Lehrbuch Antike Oldenbourg München <num> ISBN <num>-<num>-<num>-<num> Umfassender und zugleich origineller Einstieg in die antike Geschichte der alle wichtigen Themen abdeckt die Ereignisgeschichte wird aber nur sehr sehr knapp behandelt
Profile History of the Ancient World Profile London sortiert nach Epochendarstellung aktuelle und gut lesbare Überblickswerke
Angelos Chaniotis Age of Conquests The Greek World from Alexander to Hadrian <num>
Kathryn Lomas The Rise of Rome
From the Iron Age to the Punic Wars
<num>
David Potter The Origin of Empire
Rome from the Republic to Hadrian
<num>
Michael Kulikowski The Triumph of Empire
The Roman World from Hadrian to Constantine
<num>
Michael Kulikowski The Tragedy of Empire
From Constantine to the Destruction of Roman Italy
geplant für <num>
Routledge History of the Ancient World Routledge Verlag London
New York
Amélie Kuhrt The ancient Near East <num> Bände
<num> ISBN <num>-<num>-<num>-<num> Band <num> ISBN <num>-<num>-<num>-<num> Band <num> recht umfassende Darstellung der altorientalischen Geschichte bis zu den Achaimeniden
Robin Osborne Greece in the making <num>-<num> B C <num> ISBN <num>-<num>-<num>-X
Simon Hornblower The Greek world <num>-<num> B C <num> Auflage
<num> ISBN <num>-<num>-<num>-<num>-<num> hervorragende Gesamtdarstellung der klassischen Zeit
Graham Shipley The Greek world after Alexander <num>-<num> B C <num> ISBN <num>-<num>-<num>-<num> mit die beste Gesamtdarstellung des Hellenismus
Timothy J Cornell The beginnings of Rome
Italy and Rome from the Bronze Age to the Punic Wars c <num>-<num> B C
<num> ISBN <num>-<num>-<num>-<num>
Martin Goodman The Roman world <num> B C-A D <num> <num> ISBN <num>-<num>-<num>-<num>
David S Potter The Roman empire at Bay AD <num>-<num> <num> ISBN <num>-<num>-<num>-<num> <num> Aufl <num> hervorragende Darstellung die auch soziokulturelle Aspekte mit einbezieht
Averil Cameron The Mediterranean world in Late Antiquity A D <num>-<num> <num> ISBN <num>-<num>-<num>-<num> <num> Auflage <num> eine ausgezeichnete englische Einführung in die Spätantike
Klassiker
Zum Teil veraltet
Älteren Datums aber bis heute noch grundlegend sind die Darstellungen zur griechischen Geschichte von Karl Julius Beloch Georg Busolt und Eduard Meyer
Karl Julius Beloch Griechische Geschichte <num> Bände in <num> Teilbände
Straßburg <num>ff
<num> überarb
Auflage
<num>ff
Bedeutende aber teilweise umstrittene Darstellung
Georg Busolt Griechische Geschichte bis zur Schlacht bei Chaeroneia <num> Bände in <num> Perthes Gotha <num>-<num>
Johann Gustav Droysen Geschichte des Hellenismus Perthes Gotha <num> auf CD-ROM Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
Matthias Gelzer Julius Caesar
Der Politiker und Staatsmann
Callwey München <num> <num> Auflage
Nachdr Steiner Wiesbaden <num> ISBN <num>-<num>-<num>-<num>
Edward Gibbon Verfall und Untergang des römischen Imperiums <num> Bände dtv München <num> ISBN <num>-<num>-<num>-<num> - Original
The History of the Decline and Fall of the Roman Empire <num> Bände im Quartoformat
London <num>-<num> Zum ersten Mal komplette und ungekürzte dt Übersetzung bis zum Ende Westroms die Geschichte von Byzanz ist immer noch ausgespart
Lesenswert aber inhaltlich bzw hinsichtlich der Wertung veraltet
Eduard Meyer Geschichte des Altertums <num> Bände <num> Auflage
Darmstadt <num> orig <num>-<num> online
Theodor Mommsen Römische Geschichte Weidmann Berlin <num> Nachdr dtv München <num> ISBN <num>-<num>-<num>-<num>
Klassiker inhaltlich veraltet
Einzeldarstellungen
Griechenland - Hellas
Karl-Wilhelm Welwei Griechische Geschichte
Von den Anfängen bis zum Beginn des Hellenismus
Schöningh Paderborn u a <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelle und recht umfassende Darstellung bis ins späte <num> Jahrhundert v Chr
Detlef Lotze Griechische Geschichte
Von den Anfängen bis zum Hellenismus
München <num> ISBN <num>-<num>-<num>-<num>-<num> Siehe auch weitere Bände aus dieser Reihe von Ernst Baltrusch Klaus Bringmann Hartwin Brandt Peter Funke Mischa Meier Karl-Wilhelm Welwei Josef Wiesehöfer etc Jedoch nur für den ersten Überblick geeignet
Oswyn Murray Das frühe Griechenland München <num> <num> Auflage
<num> ISBN <num>-<num>-<num>-<num> ausgezeichnete Darstellung der griechischen Frühzeit bis hin zu den Perserkriegen
John K Davies Das klassische Griechenland und die Demokratie München <num> <num> Auflage
<num> ISBN <num>-<num>-<num>-<num>
Christian Meier Athen
Ein Neubeginn der Weltgeschichte
Berlin <num> ISBN <num>-<num>-<num>-<num> Gesamtdarstellung Athens im <num> Jahrhundert aber ohne Anmerkungen
Frank W Walbank Die hellenistische Welt München <num> <num> Auflage
<num> ISBN <num>-<num>-<num>-<num>
Hermann Bengtson Griechische Geschichte
Von den Anfängen bis in die römische Kaiserzeit
Handbuch der Altertumswissenschaft III
<num> Reprint der <num> durchgesehen und erg Auflage von <num> München <num> ISBN <num>-<num>-<num>-<num> Als Ausgabe ohne wissenschaftlichen Apparat Griechische Geschichte <num> Auflage
München <num> ISBN <num>-<num>-<num>-X inhaltlich weitgehend veraltet
Rom
Klaus Bringmann Geschichte der römischen Republik München <num> ISBN <num>-<num>-<num>-<num> solide Darstellung
Karl Christ Geschichte der römischen Kaiserzeit <num> aktual
Auflage
München <num> ISBN <num>-<num>-<num>-<num> beste deutsche Darstellung der Kaiserzeit bis Konstantin dem Großen
Michael Sommer Römische Geschichte I Rom und die antike Welt bis zum Ende der Republik
Kröners Taschenausgabe Band <num>
Kröner Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelle und gut lesbare Darstellung der republikanischen Zeit
Michael Sommer Römische Geschichte II
Rom und sein Imperium in der Kaiserzeit
Kröners Taschenausgabe Band <num>
Kröner Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelle und gut lesbare Darstellung der Kaiserzeit
Hermann Bengtson Grundriss der Römischen Geschichte mit Quellenkunde
Republik und Kaiserzeit bis <num> n Chr
Handbuch der Altertumswissenschaft III
<num> München <num> ISBN <num>-<num>-<num>-<num> Inhaltlich inzwischen weitgehend veraltet
Alexander Demandt Die Spätantike Handbuch der Altertumswissenschaft III
<num> München <num> <num> überarbeitete Auflage
München <num> Als inhaltlich gekürzte Ausgabe ohne wissenschaftlichen Apparat Geschichte der Spätantike München <num> ISBN <num>-<num>-<num>-<num>
Arnold Hugh Martin Jones The Later Roman Empire <num>-<num>
A Social Economic and Administrative Survey
<num> Bände Oxford <num> Neudruck in <num> Bände Baltimore <num>
Umfassendste moderne von einem Autor verfasste Darstellung der Spätantike jedoch durch die Faktendichte teils schwer lesbar und inzwischen vor allem in den Wertungen teilweise überholt
Scott Fitzgerald Johnson Hrsg The Oxford Handbook of Late Antiquity Oxford u a <num>
Spezielle Literatur
Nur in Auswahl
Es sei auch auf die oben genannten Fachlexika verwiesen
Allgemein
Kulturgeschichte der Antiken Welt Verschiedene Verfasser Band <num>ff Mainz <num>ff
Griechenland - Hellas
Jochen Bleicken Die athenische Demokratie <num> Auflage
Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Donald Kagan The Peloponnesian War London <num> ISBN <num>-<num>-<num>-<num> Siehe auch Kagans vierbändige Darstellung des Pelop
Krieges hier eine intelligente und zusammenfassende Darstellung für ein breiteres Publikum
Michael Rostovtzeff A Social and Economic History of the Hellenistic World <num> Bände
<num>
Michael Stahl Gesellschaft und Staat bei den Griechen <num> Bände Schöningh Paderborn <num> Band <num> ISBN <num>-<num>-<num>-<num> Band <num> ISBN <num>-<num>-<num>-<num> sehr gutes Überblickswerk
Karl-Wilhelm Welwei Das klassische Athen
Demokratie und Machtpolitik im <num> und <num> Jahrhundert
Darmstadt <num> ISBN <num>-<num>-<num>-<num> Detaillierte Darstellung der Politik Athens und dessen Aufstieg zur Hegemonialmacht
Karl-Wilhelm Welwei Sparta
Aufstieg und Niedergang einer antiken Großmacht
Stuttgart <num> ISBN <num>-<num>-<num>-<num> Wohl die beste deutschsprachige Darstellung der Geschichte Spartas
Karl-Wilhelm Welwei Die griechische Polis
Verfassung und Gesellschaft in archaischer und klassischer Zeit
<num> Auflage
Stuttgart <num> ISBN <num>-<num>-<num>-<num>
Rom
Aufstieg und Niedergang der römischen Welt Berlin und New York <num>ff
Jochen Bleicken Verfassungs- und Sozialgeschichte des Römischen Kaiserreiches <num> Bände
Paderborn München Wien Zürich <num> Band <num> ISBN <num>-<num>-<num>-<num> Band <num> ISBN <num>-<num>-<num>-<num>
PersienIran
Encyclopædia Iranica
London <num> ff Onlineportal
Touraj Daryee Hrsg King of the Seven Climes
A History of the Ancient Iranian World <num> BCE-<num> CE
UCI Jordan Center for Persian Studies Irvine CA <num>
Josef Wiesehöfer Das antike Persien
Von <num> v Chr bis <num> n Chr
Aktual
Neuauflage Patmos Düsseldorf <num> ISBN <num>-<num>-<num>-<num> gutes Überblickswerk dort auch weitere Hinweise
Germanen
Reallexikon der Germanischen Altertumskunde
<num> Auflage
Bruno Bleckmann Die Germanen
Von Ariovist zu den Wikingern
CH Beck Verlag München <num>
Walter Pohl Die Germanen <num> Auflage
Oldenbourg München <num>
Walter Pohl Die Völkerwanderung
Eroberung und Integration
<num> Auflage
Kohlhammer Stuttgart u a <num>
Kelten
Bernhard Maier Die Kelten
Ihre Geschichte von den Anfängen bis zur Gegenwart
<num> vollständig überarbeitete und erweiterte Auflage
CH Beck München <num>
Wolfgang Meid Die Kelten <num> verbesserte Auflage
Reclam Stuttgart <num>
Skythen Hunnen und andere Steppenvölker
Christoph Baumer The History of Central Asia Band <num> und <num> IB
Tauris London <num>ff
Valerie Hansen The Silk Road
A History with Documents
Oxford University Press Oxford <num>
Hyun Jin Kim The Huns Routledge New York <num>
St John Simpson Svetlana Pankova Hrsg Scythians
Warriors of ancient Siberia
Thames
Hudson London <num>
Timo Stickler Die Hunnen CH Beck München <num>
Indien und China
Raoul McLaughlin Rome and the Distant East
Trade Routes to the Ancient Lands of Arabia India and China
Continnuum LondonNew York <num>
Walter Scheidel Hrsg Rome and China
Comparative Perspectives on Ancient World Empires
Oxford University Press Oxford u a <num>
Richard Stoneman The Greek Experience of India
From Alexander to the Indo-Greeks
Princeton University Press Princeton <num>
Geschichtsschreibung
Dieter Flach Römische Geschichtsschreibung <num> Aufl WBG Darmstadt <num>
Gabriele Marasco Hrsg Greek and Roman Historiography in Late Antiquity
Fourth to Sixth Century AD
Leiden u a <num>
John Marincola Hrsg A Companion to Greek and Roman Historiography <num> Bde Blackwell Oxford <num>
Klaus Meister Die griechische Geschichtsschreibung Kohlhammer Stuttgart <num>
Militärgeschichte
Leonhard Burckhardt Militärgeschichte der Antike C H Beck München <num> ISBN <num>-<num>-<num>-<num>-<num>
Brian Campbell Lawrence A Tritle Hrsg The Oxford Handbook of Warfare in the Classical World Oxford University Press Oxford <num> ISBN <num>-<num>-<num>-<num>-<num>
Christian Mann Militär und Kriegführung in der Antike
Enzyklopädie der griechisch-römischen Antike Band <num>
Oldenbourg München <num> ISBN <num>-<num>-<num>-<num>-<num>
Raimund Schulz
Feldherren Krieger und Strategen
Krieg in der Antike von Achill bis Attila
Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Harry Sidebottom Michael Whitby Hrsg The Encyclopedia of Ancient Battles <num> Bände
Wiley-Blackwell Malden u a <num>
Religionsgeschichte
siehe auch
Reallexikon für Antike und Christentum
Klaus Bringmann Geschichte der Juden im Altertum
Vom babylonischen Exil bis zur arabischen Eroberung
Klett-Cotta Stuttgart <num>
Werner Dahlheim Die Welt zur Zeit Jesu CH Beck München <num>
Jörg Rüpke Pantheon
Geschichte der antiken Religionen
CH Beck München <num>
Entdeckungsfahrten
Raimund Schulz Abenteurer der Ferne
Die großen Entdeckungsfahrten und das Weltwissen der Antike
Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Wirtschaftsgeschichte
Géza Alföldy Römische Sozialgeschichte <num> völlig überarbeitete und aktualisierte Auflage
Steiner Stuttgart <num>
Sitta von Reden Antike Wirtschaft
Enzyklopädie der griechisch-römischen Antike Band <num>
de Gruyter Oldenbourg Berlin u a <num> ISBN <num>-<num>-<num>-<num>-<num>
Nachwirkungen
Peter von Möllendorff Annette Simonis Linda Simonis Hrsg Historische Gestalten der Antike
Rezeption in Literatur Kunst und Musik
Der Neue Pauly
Supplemente
Band <num>
Metzler StuttgartWeimar <num> ISBN <num>-<num>-<num>-<num>-<num>
Ulrich Niggemann Kai Ruffing
In
Europäische Geschichte Online hrsg vom Institut für Europäische Geschichte Mainz <num> Zugriff am <num> August <num>
Weblinks
Sehr umfangreiche Linkliste der HU Berlin KIRKE - Linkportal Antike wohl das umfassendste dt Angebot LacusCurtius - zahlreiche antike Texte in engl Übersetzung undoder Originaltexte Perseus Project - Quellensammlung zur Antike englisch
Navicula Bacchi - Materialsammlung Alte Sprachen und Antike Geschichte Umfangreiche und teils sehr empfehlenswerte Materialsammlung bei Liviusorg
Anmerkungen
Michael Rostovtzeff hat sogar die Vermutung ausgesprochen die hellenistische Welt habe vor der Dominanz Roms geradezu an der Schwelle einer Industrialisierung gestanden - vgl A Social and Economic History of the Hellenistic World <num> Vgl dazu ausführlich Klaus-Peter Johne Hrsg Die Zeit der Soldatenkaiser <num> Bände Berlin <num> Siehe Hermann Strasburger Umblick im Trümmerfeld der griechischen Geschichtsschreibung In Historiographia antiqua Festschrift für Willy Peremans Leuven <num> S <num>-<num> Trotz all dieser Werke neueren Datums aber haben die klassischen Werke zur griechischen Geschichte von BELOCH BUSOLT und MEYER
nichts von ihrer Bedeutung verloren und sind für ernsthafte Arbeit immer heranzuziehen Wolfgang Schuller Griechische Geschichte München <num> S <num> Vgl auch Mortimer Chambers Georg Busolt his career in his letters Leiden <num> S VII Donald Kagan The outbreak of the Peloponnesian War IthacaNY <num> S VII Überblick zur neueren Forschung zur Spätantike etwa bei Philip Rousseau Hrsg A Companion to Late Antiquity Malden Massachusetts u a <num>
DateiAnthony Hope Hawkins by Alfred Ellis amp Waleryjpg Anthony Hope war das Pseudonym von Sir Anthony Hope Hawkins
<num> Februar <num> in London
<num> Juli <num> einem britischen Rechtsanwalt und Schriftsteller
Anthony Hope war ein Sohn von Reverend Edward Connerford Hawkins einem anglikanischen Geistlichen und Jane Isabella Grahame
Er verließ die Universität Oxford <num> mit einem first-class degree und wurde Anwalt in London
Er heiratete <num> hatte zwei Söhne und eine Tochter
Während des Ersten Weltkrieges arbeitete er im Ministry of Information
<num> wurde er für seine Verdienste während des Krieges zum Ritter geschlagen
Sein erstes Buch war A Man of Mark <num> später schrieb er The Dolly Dialogues <num>
Den größten Erfolg hatte er mit The Prisoner of Zenda dt Der Gefangene von Zenda Anschließend verfasste er Rupert of Henzau <num> und viele weitere Bücher
Literatur
Weblinks
Das Ångström
nach dem schwedischen Physiker Anders Jonas Ångström ist eine Maßeinheit der Länge
Das Einheitenzeichen ist Å A mit Ring Ein Ångström entspricht dem zehnmillionsten Teil eines Millimeters
Das Ångström ist keine SI-Einheit
<num> Å
<num> fm
<num> pm
<num> nm
<num>-<num> μm
<num>-<num> mm
<num>-<num> cm
<num>-<num> m
Das Ångström wird insbesondere in der Kristallographie und der Chemie benutzt um mit einfachen Zahlenwerten arbeiten zu können
So ist <num> Å die typische Größenordnung für Atomradien Abstände von Atomen in Kristallstrukturen und Bindungslängen in Molekülen
Der Radius isolierter neutraler Atome beträgt zwischen <num> und <num> Å
Daher wird das Ångström oft als Einheit für Abstände in atomaren Größenordnungen verwendet z B
für die Dicke sehr dünner Schichten für die Angabe der verwendeten Wellenlänge der Röntgenstrahlung bei ihrer Ermittlung in Röntgenbeugungs experimenten wie der Kristallstrukturanalyse sowie für die Porengröße von stationären Phasen in flüssigchromatographischen Säulen für die Hochleistungsflüssigkeitschromatographie HPLC
In der Thermodynamik wird die mittlere freie Weglänge der sich bewegenden Moleküle häufig in Ångström angegeben
Auch in der Optik und der Astronomie wird es zur Angabe einer Wellenlänge genutzt allerdings weniger in deutschsprachigen sondern eher in englischsprachigen Fachpublikationen
Einen ähnlichen Versuch zu einfach handhabbaren Zahlenwerten zu kommen unternahm <num> Manne Siegbahn mit der Definition der X-Einheit die etwa <num>-<num> m entsprach
Das Ångström setzte sich aber durch
Da das Ångström nicht in der Einheitenrichtlinie aufgeführt wird ist es in der EU keine gesetzliche Einheit nach der schweizerischen Einheitenverordnung auch nicht in der Schweiz
In DIN <num>-<num> ist sie ausdrücklich als nicht mehr zugelassene Einheit aufgelistet
Darstellung in Computersystemen
Laut Unicode-Standard soll die Längeneinheit Ångström durch den Großbuchstaben Å U<num>C<num> dargestellt werden
Unicode enthält zwar auch ein Zeichen namens ANGSTROM SIGN Ångströmzeichen U<num>B Å dieses wurde jedoch lediglich zur Kompatibilität mit älteren Zeichenkodierungsstandards aufgenommen und soll in neu erstellten Texten nicht verwendet werden
Quellen
Weblinks
Duden Großes Fremdwörterbuch ISBN <num>-<num>-<num>-<num>-<num> Eintrag Ångström S <num>
Das Ampere
mit Einheitenzeichen A benannt nach dem französischen Mathematiker und Physiker André-Marie Ampère ist die SI-Basiseinheit der elektrischen Stromstärke und zugleich SI-Einheit der abgeleiteten Größe magnetische Durchflutung
Obwohl man den Nachnamen des Namensgebers mit
accent grave
schreibt Ampère wird die SI-Einheit im deutschen und englischen Sprachraum üblicherweise ohne Akzent geschrieben also Ampere
Definition
DateiAmpere coulombsvg
Ein Ampere entspricht einem Fluss von <num> Coulomb C pro Sekunde durch den Leiterquerschnitt
Das Coulomb ist im Internationales Einheitensystem über die festgelegte Elementarladung
definiert
Ein Ampere entspricht dann genau einem Strom von
Elementarladungen pro Sekunde
Bei einem Fluss von Elektronen sind dies ca <num> Trillionen Elektronen pro Sekunde
Ein Fluss von <num> A über eine Spannung von <num> Volt V bedeutet eine Leistung von <num> Watt W
Historisches
Bevor das Ampere als internationale Einheit der Stromstärke festgelegt wurde gab es eine Reihe von unterschiedlichen Einheiten und Definitionen
In Deutschland und einigen anderen Ländern war die Webersche Einheit der Stromstärke in Gebrauch dabei war <num> Weber-Einheit
<num> Ampere
In Großbritannien schlug man zunächst vor die Einheit der Stromstärke mit Galvat nach dem italienischen Biophysiker Luigi Galvani zu benennen die in etwa dem heutigen Ampere entsprochen hätte Später wurde ebenfalls eine Weber-Einheit für die Stromstärke eingeführt die aber einen zehnmal so hohen Wert hatte wie die in Deutschland gebräuchliche
Noch verwickelter wurde es dadurch dass der Name Weber auch für die Einheit der elektrischen Ladung benutzt wurde so dass dann die Stromstärke gleich Weber-EinheitSekunde war
Zeitweise gab man der Weber-Einheit auch den Namen Farad womit später die Einheit der elektrischen Kapazität benannt wurde
Stromstärke als Basiseinheit
Würde man die Stromstärke mit einer abgeleiteten Einheit messen wie das etwa beim CGS-Einheitensystem geschieht so ließen sich die elektrischen Größen durch die Basiseinheiten nur mit nicht ganzzahligen Exponenten ausdrücken
Um das zu vermeiden wurde schon <num> die Einheit der Stromstärke als weitere Basiseinheit vorgeschlagen
Definition <num>
<num> wurde <num> Ampere im Gesetz betreffend die elektrischen Maßeinheiten des Deutschen Kaiserreichs als die Stärke desjenigen Stromes definiert der aus einer wässrigen Silbernitrat-Lösung mittels Elektrolyse in einer Sekunde <num> mg Silber abscheidet
Das so definierte Ampere ist später als internationales Ampere bezeichnet worden das mit den restlichen Basiseinheiten kompatible dagegen als absolutes Ampere
Definition <num>
DateiAmpere-defsvg <num> wurde das Ampere wie folgt über die Lorentzkraft zweier Leiter aufeinander definiert
<num> A ist die Stärke des zeitlich konstanten elektrischen Stromes der im Vakuum zwischen zwei parallelen unendlich langen geraden Leitern mit vernachlässigbar kleinem kreisförmigem Querschnitt und dem Abstand von <num> m zwischen diesen Leitern eine Kraft von <num><num>-<num> Newton pro Meter Leiterlänge hervorrufen würde
Mit dieser Definition wurde zugleich der Wert der magnetischen Feldkonstante μ<num> festgelegt
Neudefinition des Ampere <num>
Am <num> November <num> wurde auf der <num> Generalkonferenz für Maß und Gewicht beschlossen das Ampere und andere SI-Basiseinheiten mit Wirkung zum <num> Mai <num> neu zu definieren
Mit dieser Neudefinition des Internationalen Einheitensystems basiert das Ampere auf einer Definition der Elementarladung Seitdem hängt die Definition des Amperes nur mehr von der Definition der Sekunde ab nicht mehr jedoch vom Meter und vom Kilogramm
Die Neudefinition wurde vorgenommen da diese leichter zu realisieren ist
Die magnetische Feldkonstante μ<num> ist seitdem eine mit einer Messunsicherheit behaftete Messgröße die experimentell bestimmt werden muss
Einzelnachweise
Weblinks
Ampere-Definition LEIFI
Ampere Einzelelektronentunneln SET Physikalisch-Technische Bundesanstalt Forschung zum neuen SI
J G Crowther British Scientists of the Nineteenth Century Routledge
Kegan Paul London <num> S <num> Wilhelm Jaeger Die Entstehung der internationalen Maße der Elektrotechnik Julius Springer Verlag Berlin <num> S <num>-<num> Gesetz auf WikiSource
Acre Plural deutsch Acre oder Acres
Plural acres ist eine von den Britischen Inseln stammende angloamerikanische Maßeinheit zur Flächenbestimmung von Grundstücken und entspricht grob <num> m beziehungsweise <num> Ar
Neben dem Acre wird im heutigen angloamerikanischen Flächenmaßsystem zur Land- und Grundvermessung praktisch nur noch die Flächeneinheit Square Foot verwendet in den Vereinigten Staaten wird die Größe von Grundstücken allein mit diesen beiden Flächeneinheiten angegeben
Weit verbreitet sind diese Einheiten auch in Großbritannien Kanada Indien Australien und anderen Commonwealth-Staaten obwohl dort heute ein metrisches Hauptmaßsystem besteht
Begriff
Definition
Heutzutage wird der Acre direkt mit <num> Square Feet definiert weil die zur ursprünglichen Definition verwendeten Längenmaße Furlong
<num> Fuß und Chain
<num> Fuß mittlerweile ungebräuchlich sind
Unter Einbezug der Meile sowie den heutzutage nicht mehr gebräuchlichen Flächenmaßen Rood und Square Rod auch als Square Perch Perch Square Pole Pole bezeichnet ergibt sich die folgende Umrechnung
Praktische Verwendung
Der Acre ist das Hauptmaß für Grundstücksflächen
In der Regel werden nicht mehr als zwei Nachkommastellen angegeben womit eine Genauigkeit von <num> m vorliegt
Sobald genauere Angaben erforderlich sind beispielsweise bei Bauland wird die Flächeneinheit Square Foot verwendet
Bei landwirtschaftlich genutzten Grundstücken werden die Flächen in Workable Acre und Non Workable Acre unterteilt
Damit gemeint sind die tatsächlich nutzbare Fläche und die für landwirtschaftliche Zwecke nicht nutzbare Fläche wie beispielsweise Ödland
Auch sehr große Grundflächen werden in Acre angegeben beispielsweise <num> ac
<num> km
Eine Umrechnung in Quadratmeilen erfolgt in der Regel nicht
Acre als Grundlage für abgeleitete Einheiten
Im Bereich der Landwirtschaft bezieht sich der Flächenertrag auf den Acre
Bei Getreide wird der Ertrag in bushelacre angegeben
Siehe Hauptartikel Bushel Getreidemaß
Der Preis für Land aller Arten wird in den Vereinigten Staaten und Kanada in acre angegeben
Der
acre-foot
sowie der acre-inch sind in den Vereinigten Staaten Volumeneinheiten für große Wassermengen beispielsweise beim kommunalen Wasserverbrauch oder bei landwirtschaftlicher Bewässerung
Geschichte
Ursprüngliche Definition
Die Einheit acre von altenglisch æcer Acker Feld bezeichnete ursprünglich den Landstreifen der mit einem Ochsengespann in einem Tag gepflügt werden konnte
Unter König Eduard I sowie erneut unter Eduard III und Heinrich VIII wurde der Acre gesetzlich als ein Stück Land mit der Länge von <num> Rods oder Perches
<num> Furlong oder <num> Feet und der Breite von <num> Rods oder Perches
<num> Feet oder seit <num> <num> Chain beziehungsweise <num> Square Rods Quadratruten bei welcher Grundstücksform auch immer definiert
Mit seiner Größe von grob <num> Ar ist der Acre typologisch vergleichbar mit dem Morgen dem Tagewerk oder Tagwan dem Joch oder Juchart und dem Mannwerk
Angloamerikanische Maßreform <num>
Die weltweit unterschiedlichen angloamerikanischen Längeneinheiten wurden <num> vereinheitlicht
In den Vereinigten Staaten ergab dies für die bis dahin verwendeten Längenmaße gegenüber den neuen internationalen Längenmaßen eine Vergrößerung um den Faktor <num>
Bei der Landvermessung hätte dies bei großen Entfernungen zu spürbaren Differenzen geführt
Bei einer Streckenlänge von beispielsweise <num> km wäre der Unterschied <num> m
Um die bestehenden Werte nicht ändern zu müssen wurde deshalb in den Vereinigten Staaten das alte Maßsystem - nur für den Zweck der Landvermessung - beibehalten und das bisher verwendete Längenmaß
Foot
erhielt die Bezeichnung
Survey Foot
In den Vereinigten Staaten basiert die Flächeneinheit Acre auf dem Survey Foot der Zusatz Survey wird in der Regel weggelassen sonst ist der International Foot die Grundlage
Der auf den US
Survey Foot
basierende Acre ist um etwa <num> cm geringfügig größer
Historische Einheiten
Obgleich auf den Britischen Inseln die Größe des Acres seit dem Hochmittelalter mit <num> Square Rods definiert war war dessen Fläche je nach Ort und Zeit uneinheitlich da die Längeneinheit Rod oder Perch verschiedenen Fuß-Äquivalenten entsprach
Erst mit der Neudefinition der Imperial Units durch den Weights and Measures Act von <num> wurde ein für das gesamte Britische Weltreich einheitlicher Acre geschaffen
Vor der Einführung des Imperial Standard Acre Statute Acre gab es unter anderem den alten schottischen Acre den neuen schottischen Acre auch als Cunningham Acre bezeichnet oder den irischen bzw Plantation Acre
Beispielsweise hat der Cunningham Acre etwa die <num>-fache Größe der Plantation Acre grob die <num>-fache Größe des heutigen Acres
Einige dieser veralteten Maße waren teilweise bis ins <num> Jahrhundert gebräuchlich so in abgelegenen Gebieten Irlands
Literatur
Herbert Arthur Klein The Science of Measurement
A Historical Survey
Dover Publications Mineola NY <num>
Johann Friedrich Krüger Vollständiges Handbuch der Münzen Maße und Gewichte aller Länder der Erde Verlag Gottfried Basse QuedlinburgLeipzig <num>
Weblinks
Einzelnachweise
Flexion von Acre canoonet abgerufen am <num> Dezember <num> und Rechtschreibung Acre dudende abgerufen am <num> Dezember <num> Oxford English Dictionary Band I Seite <num> f - Vgl ferner Herbert Arthur Klein The Science of Measurement A Historical Survey Dover Publications Mineola NY <num> S <num> Zu Irland vgl
Apostilb Einheitenzeichen asb ist eine veraltete Einheit der Leuchtdichte selbstleuchtender Körper
<num> wurde Blondel Einheitenzeichen blondel als weiterer Name vorgeschlagen der Name wurde zum Andenken an den französischen Physiker André-Eugène Blondel gewählt
Eine Benutzung oder offizielle Festlegung dieses Namens ist derzeit nicht nachweisbar
Seit <num> ist das Apostilb keine offizielle Einheit mehr
Es ist eine Untereinheit des Stilb Einheitenzeichen
und darüber verknüpft mit dem Lambert Einheitenzeichen
Die entsprechende SI-Einheit ist cdm bzw das Nit
Weblink
Luminance Unit Measurement Converter
Einzelnachweise
sizescom
nach Journal of the Optical Society of America volume <num> pages <num>-<num>
Das oder der Ar in der Schweiz die Are ist eine Flächenmaßeinheit im metrischen System von <num>nbspm<sup><num><sup> mit dem Einheitenzeichen a oft jedoch nicht oder falsch abgekürzt Ar bzw ar
<num>nbspa ergeben <num>nbspha
Ein Quadrat mit dem Flächeninhalt von <num> a hat eine Kantenlänge von zehn Metern man spricht daher auch von einem Quadratdekameternbspdam<sup><num><sup>
Das Ar ist keine SI-Einheit im Gegensatz zum Hektar ist sie nicht einmal zum Gebrauch mit dem SI zugelassen
In der EU und der Schweiz ist der Ar bzw die Are gesetzliche Einheit für die Angabe der Fläche von Grund- und Flurstücken
Geschichte
Im Jahr <num> wurde in Frankreich das Meter als der <num>-millionste Teil des Erdquadranten auf dem Meridian von Paris festgelegt
Zugleich wurde die Einheit are in Anlehnung an das lateinische Wort ārea Fläche freier Platz für die Fläche von <num> m<num> neu geschaffen
Sie war anfangs die einzige gebräuchliche metrische Flächeneinheit samt ihren Teilen und Vielfachen Zentiar <num> ca
<num> m<num> und Hektar <num> ha
<num> a
Im Jahr <num> wurde die Maßeinheit unter der Bezeichnung Ar auch in Deutschland amtlich eingeführt
Vielfache und Teile
<num> Hektar von Hekto-Ar
<num> ha
<num> a
<num> m<num>
<num> hm<num>
<num> m
<num> m
<num> Dekar von Deka-Ar
<num> daa
<num> a
<num> m<num>
<num> Ar
<num> a
<num> m<num>
<num> dam<num>
<num> m
<num> m
<num> Zentiar
<num> a
<num> m<num>
<num> m<num>
<num> m
<num> m
Außer Ar und Hektar sind diese Vielfachen und Teile im deutschen Sprachraum ungebräuchlich und nur noch von historischem Interesse
Das Dekar wird als Flächenmaß in der bulgarischen Landwirtschaft in Griechenland Stremma in der Türkei und einigen Staaten des Nahen Ostens metrisches Dunam verwendet
Siehe auch
Acre Morgen
Weblinks
Einzelnachweise In Tabelle <num> der SI-Broschüre <num> Auflage ist das Ar nicht genannt In der <num> Auflage von <num> sind noch beide enthalten Im
urlhttpwwwbipmorgutilscommonpdfCCU<num>pdf
wayback<num>
text<num> Meeting des CCU <num> Seite <num> PDF <num> MB heißt es noch dass beide in Tabelle <num> erscheinen sollen Das Ar wurde dann offenbar als minor change in einem editorial meeting eliminiert auf das im nachfolgenden
urlhttpwwwbipmorgutilscommonpdfCCU<num>pdf
wayback<num>
text<num> Meeting Seite <num> PDF <num> kB Bezug genommen wird C Bopp Die internationale Maß- Gewichts- und Münz-Einigung durch das metrische System Julius Maier Stuttgart <num>
Arbeit ist eine zielbewusste und sozial durch Institutionen Bräuche abgestützte besondere Form der Tätigkeit mit der Menschen seit ihrer Menschwerdung in ihrer Umwelt zu überleben versuchen
Zur Anthropologie der Arbeit
Es ist bereits strittig ob man zielgerichtete körperliche Anstrengung von Tieren zum Beispiel den instinktiven Nestbau oder das andressierte Ziehen eines Pfluges als Arbeit bezeichnen kann
Die philosophische Anthropologie geht zumeist davon aus dass Arbeit erst im Tier-Mensch-Übergangsfeld erscheint vgl zum Beispiel Friedrich Engels Anteil der Arbeit an der Menschwerdung des Affen MEW <num>
Dabei wird meist angenommen dass die Resultate menschlicher Arbeit als Gegenstände wie in einem Spiegel dem Menschen sich selbst zeigen so dass er angesichts ihrer des Selbstbewusstseins mächtig wird
Das könnten aber auch andere menschliche Tätigkeiten bewirken so dass Arbeit gerade in ihren ursprünglichen Formen schwer von anderen menschlichen Überlebensstrategien wie Spiel oder Kunst zu trennen ist
Seit der Urgeschichte ist so Karl Bücher ein Basiszusammenhang von Arbeit und Rhythmus anzunehmen vgl das Arbeitslied
Im Vergleich zu modernen Erwerbstätigen hatten Jäger und Sammler laut zahlreichen Studien mehr Zeit zur freien Verfügung
Siehe hierzu Abschnitt Alltag und Lebenserwartung im Artikel Jäger und Sammler
Einstellung zur Arbeit Kulturelle Unterschiede
Die Auffassung welche Tätigkeiten als Arbeit betrachtet werden und welche Einstellung die Menschen dazu haben sind kulturell sehr unterschiedlich und unterliegen einem ständigen sozialen Wandel
In den industrialisierten Kulturen haben Arbeit und Beruf einen hohen Stellenwert da das marktwirtschaftlich organisierte Wirtschaftssystem und der erwünschte Fortschritt auf leistungswillige Arbeitnehmer angewiesen ist
Das war nicht immer so Vor der industriellen Revolution lebte ein Großteil der Menschen von autonomer Subsistenzwirtschaft
Dies wandelte sich dann in kurzer Zeit zu einer stark reglementierten und hierarchisch organisierten Arbeitswelt der von den Arbeitern einen erheblich höheren Zeitaufwand erforderte als die Selbstversorgung
In dieser Zeit entstand die Bewertung der Arbeit als Leid und Mühsal
Seitdem haben sich die zeitliche und körperliche Belastung die Entlohnung sowie die rechtliche Stellung der Arbeitnehmer kontinuierlich verbessert
Andererseits wird heute jedoch viel mehr Flexibilität bezüglich der Fortbildung bis hin zur Umschulung der Arbeitsplätze und -zeiten erwartet
Im Westen wird Arbeit heute vielfach als notwendiges Übel gesehen welches allerdings Rang und Ansehen garantiert und unter Umständen ein Weg zur Selbstverwirklichung werden kann
Der fortschreitende Wandel führt dabei zu einer stetig neuen Auseinandersetzung mit dem Stellenwert der Arbeit
Demgegenüber gibt es Gesellschaften in denen Menschen die von unselbstständiger Lohnarbeit leben ähnlich wie während der Industriellen Revolution im Westen nur geringes Ansehen genießen und ihre Leistung nur widerwillig erbringen weil der Lohn gering ist und die Arbeitszeit einen Großteil des Tagesablaufes bestimmt
In Ländern wo die Bevölkerung noch vorwiegend autonom von traditionellen Subsistenzformen lebt wird Lohnarbeit nur geschätzt da ihre Bedingungen dem Einzelnen weitaus weniger Möglichkeiten bisweilen auch mehr Freizeit eröffnen als dem eigenständigen Bauern oder Jäger
Dies gilt auch dort wo die Reziprozität gegenseitige unentgeltliche Hilfe innerhalb einer lokalen Gemeinschaft noch eine größere Rolle spielt als die Geldwirtschaft
Die selbstbestimmte Arbeit wird hier ungleich höher geschätzt sie wird oftmals begrifflich nicht von der Freizeit unterschieden und gilt nicht als mühevoller Überlebenskampf sondern als sinngebende Lebensaufgabe
Bei einigen naturverbundenen Ethnien ist die traditionelle Arbeit eine religiöse Handlung die das Bündnis zwischen Menschen Ahnen und Umwelt aufrecht erhält
Da diese tiefe Bedeutung bei der Lohnarbeit fehlt mangelt es häufig auch an ausreichender Motivation zur Arbeit
Westliche Arbeitgeber empfinden das als Faulheit oder mangelnde Bereitschaft zur Entwicklung bis hin zur Rückständigkeit
Dies gilt besonders für streng egalitäre Gesellschaften bei denen jegliche Arbeit negativ gesehen wird weil sie etwa mit Habgier egoistischem Streben oder Reichtum auf Kosten Anderer gleichgesetzt wird
Wortgeschichte
Das Wort Arbeit ist gemeingermanischen Ursprungs arbējiðiz got arbaiþs die Etymologie ist unsicher evtl verwandt mit indoeurop
orbh- verwaist Waise ein zu schwerer körperlicher Tätigkeit verdungenes Kind vgl Erbe evtl auch verwandt mit aslaw
robota Knechtschaft Sklaverei vgl Roboter
Im Alt- und Mittelhochdeutschen überwiegt die Wortbedeutung Mühsal Strapaze Not redensartlich noch heute Mühe und Arbeit vgl Psalm <num> lateinisch labor et dolor
Das französische Wort travail hat eine ähnliche sogar noch extremere Wortgeschichte hinter sich es leitet sich von einem frühmittelalterlichen Folterinstrument ab
Das italienische lavoro und englische labour amerikanisch labor gehen auf das lateinische labor zurück das ebenfalls primär Mühe bedeutet
Viele Redensarten sind mit ihr verbunden
So wurde harte körperliche Arbeit früher als
Kärrnerarbeit
bezeichnet und eine Schweinearbeit bedeutet unangenehm viel Arbeit Wer die Arbeit kennt und sich nicht drückt
der ist verrückt
Geschichtsschreibung
Die Geschichtsschreibung der Arbeit begann erst im <num> Jahrhundert zuerst in Frankreich England und den USA zu entstehen
Eine frühe Ausnahme innerhalb der deutschen Historiker war Karl Lamprecht <num>-<num>
Ein neueres Buch stammt von Arne Eggebrecht und anderen
Theoriegeschichte
Antike
Aristokratische Autoren wie Xenophon Platon Aristoteles
und Cicero
würdigten den Großteil der täglichen Arbeit Handwerker Bauern Kaufleute herab
Sie galt ihnen insbesondere körperliche Arbeit als Zeichen der Unfreiheit
Sklaven dúloi und Handwerker bánausoi waren der Notwendigkeit untertan und konnten nur durch diese als unfrei verstandene Arbeit ihre Lebensbedürfnisse befriedigen
Geistige Arbeit blieb der scholé gespr scholé vorbehalten was etwa schöpferische Muße beschrieb wovon das deutsche Wort Schule herrührt
DateiIlia Efimovich Repin <num>-<num> - Volga Boatmen <num>-<num>jpg
Mittelalter
In Europa blieben - vor allem in der Landwirtschaft - Formen unfreier Arbeit von Männern und Frauen auch Kindern und Alten lange erhalten Fron Lasswirtschaft am stärksten im Russischen Reich im Deutschen Reich wurden deren letztes Überbleibsel die Schollengebundenheit in den beiden Mecklenburgs erst durch die Novemberrevolution <num> beseitigt
Noch heute existieren in großen Teilen der Welt unterschiedliche Erscheinungsformen unfreier Arbeit von der Arbeitspflicht bis hin zur Arbeitsversklavung und Zwangsarbeit
Eine positive Bewertung von Arbeit als produktiver Betätigung zur Befriedigung eigener oder fremder Bedürfnisse war im Rittertum und in der Mystik angelegt
Durch Reformation und Aufklärung rückte sie in den Vordergrund Eine neue Sicht der Arbeit als sittlicher Wert und Beruf als Berufung verstanden des Menschen in der Welt wurde von Martin Luther mit seiner Lehre vom allgemeinen Priestertum ausgeprägt
Schärfer noch wurde im Calvinismus die Nicht-Arbeit überhaupt verworfen siehe auch Protestantische Ethik
Neuzeit
In der Frühphase der Aufklärung wurde Arbeit zum Naturrecht des Menschen erklärt Jean-Jacques Rousseau
Damit wurde das feudalistische Prinzip der Legitimation kritisiert
Eigentum entsteht einzig durch Arbeit niemand hat ein von Gott gegebenes Anrecht auf Eigentum
Güter die nicht durch menschliche Arbeit entstanden sind sind Gemeinbesitz
Adam Smith unterscheidet produktive und unproduktive Arbeit
Produktive Arbeit nennt er die Arbeit deren Resultat ein verkäufliches Produkt ist
Dazu wird nicht nur der eigentliche Wertschöpfungsprozess beim Schmied der Vorgang des Schmiedens selbst gerechnet sondern auch alle Arbeiten die indirekt zur Vervollkommnung des Gutes beitragen beim Schmied das Erhalten der Glut das Pflegen von Hammer und Amboss
Unproduktiv ist hingegen die Arbeit die nicht in einem verkäuflichen Produkt resultiert zum Beispiel die mütterliche Hausarbeit
Andere Arbeiten sind von diesem Standpunkt aus nicht unnütz da sie notwendig sind um produktive Arbeit leisten zu können und werden heute zum Beispiel als reproduktiv bezeichnet beispielsweise Beamte Verwalter Soldaten
Der Frühsozialist Charles Fourier proklamierte <num> ein
Recht auf Arbeit
In der deutschen Philosophie Immanuel Kant Johann Gottfried Herder Georg Wilhelm Friedrich Hegel Johann Gottlieb Fichte wird die Arbeit zur Existenzbedingung und sittlichen Pflicht erklärt
Kant räumte in seiner Anthropologie in pragmatischer Hinsicht <num> <num> jedoch ein dass Faulheit eine Schutzfunktion habe Denn die Natur hat auch den Abscheu für anhaltende Arbeit manchem Subjekt weislich in seinen für ihn sowohl als andere heilsamen Instinkt gelegt weil dieses etwa keinen langen oder oft wiederholenden Kräfteaufwand ohne Erschöpfung vertrug sondern gewisser Pausen der Erholung bedurfte
Nach Karl Marx Werttheorie ist die menschliche Arbeitskraft als alleinige Kraft fähig das Kapital als eine Ansammlung geronnener Arbeit zu vergrößern Mehrwert zu akkumulieren
Sie tut dies im Kapitalismus unausweichlich
Praktisch spiegelt dies wider dass in der Phase der Industrialisierung freie Arbeit augenfällig zur Ware wurde und vorwiegend die düsteren Züge der damaligen Lohnarbeit annahm
So zum Beispiel in Gestalt der Kinderarbeit des Arbeiterelends der Verelendung der Arbeitsunfälle und -krankheiten der drückenden Akkordarbeit - alles dies sind Merkmale der allgemein so empfundenen Sozialen Frage
Deren Folgen wurden schon seit Hegel als Entfremdung charakterisiert Der Arbeiter hat zu seinem eigenen Arbeitsprodukt aber auch zu dem Unternehmen für das er arbeitet nur noch das bare Lohnverhältnis und kann dem gemäß nicht mehr stolz auf sie sein - in diesem Spiegel erkennt er sich selbst jedenfalls nicht mehr wieder
Für Ernst Jünger war Arbeit nicht Tätigkeit schlechthin sondern der Ausdruck eines besonderen Seins das seinen Raum seine Zeit seine Gesetzmäßigkeit zu erfüllen sucht Der Arbeiter Daher kenne Arbeit auch keinen Gegensatz außer sich selbst
Das Gegenteil von Arbeit sei nicht Ruhe oder Muße da es keinen Zustand gebe der nicht als Arbeit begriffen werden könne
Neben der produktiven Eigenschaft der Arbeit wird neuerdings Lars Clausen ihre destruktive Seite hervorgehoben am auffälligsten als harte lebensgefährliche Arbeit der Soldaten aber auch bei selbst- mitmenschen- oder umweltzerstörerischer Arbeit ist Destruktives seit je Wesensbestandteil aller Arbeit
Anders die vernichtende Tätigkeit die alltags als Vandalismus auftreten kann und einen organisatorischen Höhepunkt im KZ hatte
Arbeit und Fortschritt der Technik
Der Soziologe Rudi Dutschke und der Politologe Bernd Rabehl meinten <num> in einem Gespräch mit Hans Magnus Enzensberger der technische Fortschritt könne die Erwerbsarbeit in Zukunft erheblich reduzieren Dabei muß man bedenken dass wir fähig sein werden den Arbeitstag auf fünf Stunden zu reduzieren durch moderne Produktionsanlagen dadurch dass die überflüssige Bürokratie wegfällt
Der Betrieb wird zum Zentrum der politischen Selbstbestimmung der Selbstbestimmung über das eigene Leben
Man wird also im Betrieb täglich debattieren es wird langsam ein Kollektiv entstehen ein Kollektiv ohne Anonymität begrenzt auf zwei- bis dreitausend Leute die also immer noch eine direkte Beziehung zueinander haben
In der Zeit der <num>er und <num>er Jahre gab der technische Fortschritt sogar in der calvinistisch geprägten nordamerikanischen Gesellschaft tatsächlich wieder dem Gedanken Raum dass Fortschritt zu mehr Freizeit führen könne
Zeugnisse für die Hoffnungen gaben die Schöpfungen einer bunten Pop-Kultur mit ihren Science-Fiction-Träumen wie beispielsweise der Zeichentrickserie Die Jetsons in der technikgestütztes Faulenzen ohne moralische Bedenken als Ideal dargestellt werden konnte
Angesichts global unterschiedlicher Entwicklungen zeigte sich jedoch dass ein Ausruhen auf erreichtem Wohlstand in einer Region als Gelegenheit zum wirtschaftlichen Aufholen in anderen Regionen verstanden wurde
In jenem Zeitraum wurde besonders in Japan technischer Fortschritt in erster Linie als Weg begriffen große wirtschaftliche Fortschritte zu erzielen
Bis heute begrenzt somit ein Wettbewerb in dem der verliert der zuerst bremst die Möglichkeit aus technischem und technologischem Fortschritt mehr selbstbestimmte freie Zeit zu gewinnen
Zudem prägte Robert Solow in der Wirtschaft bereits <num> mit seinem Wachstumsmodell die Auffassung dass technologische Innovation in erster Linie als ein Multiplikator des Faktors Arbeit aufträte womit er in der Dogmengeschichte der Wirtschaft einen Ankerpunkt schuf der bis heute den Raum des Denkbaren gegenüber möglichen Alternativen wirkungsvoll abgrenzt
So schafft in der heutigen Arbeitswelt technischer Fortschritt dort wo er Freiräume erweitert vorwiegend und sogar mit zunehmender Geschwindigkeit immer neue Arbeit
Dort wo Technik schon vor Beginn des Industriezeitalters die Menschen von Arbeit befreite wurden sie oft nicht freier sondern arbeitslose Geächtete
In Deutschland nahm zwischen <num> und <num> das Arbeitsvolumen pro Kopf kontinuierlich um <num> Prozent ab
Arbeit heute
Nach wie vor wird Erwerbsarbeit nicht mit Arbeit überhaupt gleichgesetzt
Wo Arbeit auch heute noch nicht Ware ist sind zwei wesentliche Aspekte hervorzuheben
Die nach wie vor in sehr vielen Gesellschaften dominante Subsistenzarbeit ist weiterhin die Arbeit die der Mensch verrichtet um seinen Lebensunterhalt zu produzieren und so sein Überleben zu sichern englische Entsprechung Labour
als Selbstproduktion gibt schöpferische Arbeit - auffällig in den Künsten - in allen Gesellschaften Menschen die Möglichkeit sich selbst zu entfalten sich in ihr wiederzuerkennen englische Entsprechung Work
In den wohlhabenden Staaten der Welt zu denen auch Deutschland zählt wird die Erwerbsarbeit knapp
Es findet eine zunehmende Flexibilisierung Virtualisierung Automatisierung und Subjektivierung der Arbeit statt prekäre Arbeitsverhältnisse nehmen zu
Inhaltlich verschiebt sich die Arbeit immer mehr in den tertiären Sektor Dienstleistungen und in Niedriglohnländer Offshoring zumal da die Jugend- und Langzeit-Arbeitslosigkeit die Arbeit trotz ihres zentral wichtigen Charakters als Überlebenstätigkeit aus dem Feld der Erfahrung Vieler rücken
In ärmeren Ländern herrschen zugleich - zum Teil - Verhältnisse die mit denen in der Industrialisierungsphase Europas vergleichbar sind Kinderarbeit Billiglohnarbeit und fehlende soziale Absicherung sind dort häufig anzutreffende Bestandteile der Arbeitswelt
Systematik der Arbeitsverhältnisse
Dort wo Arbeit für andere verrichtet wird ist nach wie vor der Unterschied bedeutsam
zwischen den sehr vielfältigen Formen so genannter unentgeltlicher Arbeit d h
durch viele - in etwa fünf Millionen Jahren aufgetretene - Formen geldlosen sozialen Tauschs der soziale Akteure miteinander verknüpft
und der historisch erst seit gut drei Jahrtausenden aufgetretenen durch Waren oder Geld entgoltenen entgeltlichen Erwerbsarbeit
Ein Wandel einer Tätigkeit von der unentgeltlichen zur entgeltlichen Form wird auch als Kommerzialisierung bezeichnet
Unentgeltliche Arbeit
Die unentgeltliche Arbeit umfasst also historisch sehr viele Formen die auch heute vorkommen aber nicht immer als Arbeit betrachtet werden
Beispiele sind
Tätigkeiten zum Erhalt der Lebensgrundlage und der Fürsorge Subsistenzwirtschaft Haus- und Familienarbeit Care-Arbeit
der Selbstentfaltung dienende Tätigkeit heute z B
Anfertigung von Modellbauten als Hobby Wir arbeiten an der Wikipedia
freiwillige helfende schenkende Arbeit Gefälligkeitsarbeit Ehrenamt siehe auch Bürgerarbeit New Work
unfreiwillige Arbeit Sklaverei Zwangsarbeit andere Formen sozial erzwungener fremdbestimmter Tätigkeiten Beispiel Zurückschneiden einer Hecke im Interesse der Verkehrssicherheit
freiwillige allgemein nützliche Ersatzarbeit anstelle von Erwerbsarbeit
Erwerbsarbeit
Unter Erwerbsarbeit versteht man eine Arbeitsleistung gegen Entgelt Arbeitslohn im Gegensatz zu unentgeltlicher Arbeit wie Subsistenzarbeit Sklavenarbeit weiblicher Hausarbeit oder ehrenamtlicher Arbeit
Erwerbsarbeit wird in einem Beschäftigungsverhältnis Lohnarbeit oder in selbständiger und neuerdings auch in scheinselbständiger Form geleistet
Beispiele sind
Zu selbständiger bezahlter Arbeit siehe Selbständigkeit Unternehmer Kaufmann Handwerker Freiberuf freie Mitarbeit Werkvertrag
Siehe auch Ich-AG Scheinselbstständigkeit
Bei abhängiger Beschäftigung als Arbeitnehmer ist zwischen privatrechtlichen und öffentlich-rechtlichen Beschäftigungsverhältnissen zu unterscheiden
Wer in der Privatwirtschaft abhängig beschäftigt ist ist Arbeiter oder Angestellter
Zu privatwirtschaftlichen Beschäftigungsverhältnissen siehe auch Arbeitsrecht Arbeitsvertrag Arbeitsmarkt Arbeitslosigkeit
Zu irregulären privatwirtschaftlichen Beschäftigungsverhältnissen siehe Minijob Niedriglohn-Job und atypisch Beschäftigte
Der deutsche Staat beschäftigt in seinem öffentlichen Dienst sowohl Arbeiter und Angestellte privatrechtliches Arbeitsverhältnis mit Arbeitsvertrag als auch Beamte Richter Professoren und Soldaten öffentlich-rechtliches Dienstverhältnis mit Ernennungsurkunde
Das deutsche Privatrecht unterscheidet hier analog zwischen Werkvertrag der Erfolg wird geschuldet und Dienstvertrag der Dienst wird geschuldet
Mischformen
Zu den Mischformen auch als Atypische Arbeit
bzw Atypische Beschäftigung
bezeichnet gehören zahlreiche freiwillige oder gesetzlich vorgesehene Arbeiten die gering entgolten werden
Teils sind die Arbeitenden zur Verrichtung der betreffenden Tätigkeiten rechtlich verpflichtet teils fühlen sie sich ethisch hierzu verpflichtet
Zu den Mischformen gehören auch solche ehrenamtlichen Tätigkeiten für die eine Aufwandsentschädigung gezahlt wird die über den tatsächlichen Aufwand hinausgeht
Kritik der Arbeit
Was die zentrale Stellung der Arbeit in kollektiven Wertsystemen angeht sagen Kritiker der Arbeit unterscheiden sich Staatsformen und Herrschaftsmodelle erstaunlich wenig
Als Kritiker der Arbeit war Paul Lafargue Autor des Pamphlets Le droit à la paresse Das Recht auf Faulheit <num> in der alten Arbeiterbewegung ein Außenseiter
Lafargue verstand sich als revolutionärer Sozialist und dementsprechend schätzte er die kapitalistische Arbeitsethik ein
Die kapitalistische Moral eine jämmerliche Kopie der christlichen Moral belegt das Fleisch des Arbeiters mit einem Bannfluch Ihr Ideal besteht darin die Bedürfnisse des Produzenten auf das geringste Minimum zu reduzieren seine Genüsse und Leidenschaften zu ersticken und ihn zur Rolle einer Maschine zu verurteilen aus der man ohne Rast und ohne Dank Arbeit nach Belieben herausschindet Lafargues Manifest erschien <num> auf Deutsch
Lafargue zitierte Lessing
Laß uns faul in allen SachenNur nicht faul zu Lieb und WeinNur nicht faul zur Faulheit sein
Die radikalen Kritiker der Arbeit lehnen den Arbeitszwang ab - für Reiche wie für Arme
Damit unterscheiden sie sich von Sozialisten die sich über den Müßiggang der Reichen empören und fordern dass alle arbeiten müssen
Hintergrund der Ablehnung des Arbeitszwangs ist die reale Möglichkeit der Aufhebung der Arbeit
Schon Lafargue meinte dass <num> Stunden Arbeit ausreichen müssten
Aufhebung der Arbeit bedeutet jedoch nicht nur Verringerung der Arbeitszeit durch Automation und Abschaffung der Produktion von Gütern die nur um des Profits willen hergestellt werden
Unter kapitalistischen Bedingungen sind Arbeitslose wie abhängig Beschäftigte und auch diejenigen die auf das sogenannte Berufsleben vorbereitet werden gleichermaßen dem System der Lohnarbeit unterworfen
Auch wer freie Zeit hat kann diese nicht frei nutzen sei es weil andere mit denen man etwas zusammen tun möchte arbeiten müssen sei es weil die gesamte Umwelt von kommerziellen Zwängen geprägt ist
Aufhebung der Arbeit bedeutet dass auch weiterhin notwendige Tätigkeiten wie zum Beispiel die Pflege gebrechlicher Menschen einen anderen Charakter annehmen wenn sie in einem anderen nicht-hierarchischen Kontext ausgeübt werden
Dass die Menschen ohne den Zwang zu Arbeit einfach nichts tun und verhungern würden ist nach Ansicht der Kritiker der Arbeit nicht zu erwarten da sie ja bereits unter kapitalistischen Bedingungen freiwillig konstruktiv zusammenarbeiten
Die Tradition der Ablehnung der Arbeit wurde nach dem Zweiten Weltkrieg von einer Gruppe junger Menschen in Paris wiederbelebt
Unter ihnen war Guy Debord
Der Slogan Ne travaillez jamais Arbeitet niemals kehrte dann im Pariser Mai <num> wieder
Die Ablehnung der Arbeit spielte auch in Italien in den Kämpfen der <num>er und <num>er Jahre eine zentrale Rolle
Der Postanarchist Bob Black rief <num> die Proletarier dieser Welt auf sich zu entspannen da niemand jemals arbeiten solle
Bob Black versteht sich als Antimarxist und postleftistischer Individual-Anarchist
Er ruft dazu auf alle Arbeitsplätze so umzugestalten dass sie wie ein Spiel sind
Er findet es merkwürdig dass die einen sich auf dem Feld abrackern während andere in ihrer Freizeit welche nur das ebenfalls fremdbestimmte und durchorganisierte Gegenstück zur Arbeit sei bei der Gärtnerei entspannen
Zentral in seiner Kritik ist neben diesem Punkten auch der Charakter der Fremdbestimmtheit der Arbeit ob nun im Staatssozialismus oder im Kapitalismus
Im Anschluss an Michel Foucault kritisiert er Disziplinierung und die Disziplinargesellschaft und betont die zentrale Rolle der Arbeit bei der Disziplinierung Gefängnisse und Fabriken seien zur selben Zeit entstanden die Schulen seien dafür da Leistungsgedanken und -bereitschaft und Gehorsam einzuüben und es gebe mehr Freiheit in jeder einigermaßen entstalinisierten Diktatur als an einem gewöhnlichen amerikanischen Arbeitsplatz Eine ähnliche Kritik hatte allerdings auch schon Gustav Landauer vorgetragen
Auch er wollte den Arbeitstag ähnlich neu gestalten
Von einer deutschen Tradition der Arbeitskritik kann man dennoch kaum reden
Seit den <num>er Jahren bemüht sich allerdings die wertkritische Gruppe
Krisis
um eine Erneuerung der Kritik der Arbeit
Sie veröffentlichte ein
Manifest gegen die Arbeit
Die Krisis versteht sich als postmarxistisch bzw grenzt sie sich ab vom traditionellen Marxismus
Aktuell in der Kritik der Arbeit ist die Kritik der Identifikation mit der Arbeit als zentralem Element männlicher Identität
Reportagen Feldforschung und Darstellung der Arbeit in der Literatur
Im Bereich der Feldforschung wurde eine Studie der Österreichischen Wirtschaftspsychologischen Forschungsstelle berühmt
Sie hieß
Die Arbeitslosen von Marienthal
<num> und beschäftigt sich mit den Folgen plötzlich eintretender Arbeitslosigkeit für eine Dorfgemeinschaft
Darstellungen und Schilderungen der täglichen Arbeit am unteren Rand der Gesellschaft finden sich innerhalb der Belletristik etwa bei den österreichischen Autoren Franz Innerhofer und Gernot Wolfgruber dem Deutschen Hans Dieter Baroth und bei George Orwell
Erledigt in Paris und London
Siehe auch
Arbeitssoziologie
Arbeitsmigration
Arbeit Philosophie
Arbeiterliteratur
Literatur
Bücher
Sven Rahner Architekten der Arbeit Positionen Entwürfe Kontroversen edition Körber-Stiftung Hamburg <num> ISBN <num>-<num>-<num>-<num>-<num>
Andrea Komlosy Arbeit
Eine globalhistorische Perspektive
<num> bis <num> Jahrhundert
Promedia Wien <num> ISBN <num>-<num>-<num>-<num>-<num>
Bob Black Die Abschaffung der Arbeit Löhrbach <num> ISBN <num>-<num>-<num>-<num>
Harry Braverman Die Arbeit im modernen Produktionsprozeß Campus Verlag Frankfurt am Main u a <num> ISBN <num>-<num>-<num>-<num>
Karl Bücher Arbeit und Rhythmus Hirzel Leipzig <num>
Robert Castel Les métamorphoses de la question sociale une chronique du salariat <num>
deutsch Die Metamorphosen der sozialen Frage eine Chronik der Lohnarbeit Univ-Verlag Konstanz Konstanz <num>
Lars Clausen Produktive Arbeit destruktive Arbeit Verlag Walter de Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num>
Angelika Ebbinghaus Arbeiter und Arbeitswissenschaft
Zur Entstehung der Wissenschaftlichen Betriebsführung
Westdeutscher Verlag Opladen <num> ISBN <num>-<num>-<num>-<num>
Peter Fleissner Technologie und Arbeitswelt in Österreich ÖGB-Verlag <num> ISBN <num>-<num>-<num>-<num>
Reimer Gronemeyer Hrsg Der faule Neger
Vom weißen Kreuzzug gegen den schwarzen Müßiggang
Rowohlt Reinbek bei Hamburg <num> ISBN <num>-<num>-<num>-<num>
Reinhard P Gruber Nie wieder Arbeit
Schivkovs Botschaften vom anderen Leben
ISBN <num>-<num>-<num>-<num>
Simon Head The New Ruthless Economy
Work and Power in the Digital Age
Oxford UP <num> ISBN <num>-<num>-<num>-<num>
IG Metall Handbuch Gute Arbeit <num> ISBN <num>-<num>-<num>-<num>-<num>
Wulf D Hund Stichwort Arbeit Vom Banausentum zum travail attractif
Distel Verlag Heilbronn <num> ISBN <num>-<num>-<num>-<num>
Ernst Jünger Der Arbeiter
Herrschaft und Gestalt
<num>
Paul Lafargue
Das Recht auf Faulheit
Widerlegung des Rechts auf Arbeit von <num>
<num> Auflage
Trotzdem Verlag Grafenau <num> ISBN <num>-<num>-<num>-X
Severin Müller Phänomenologie und philosophische Theorie der Arbeit
Band I Lebenswelt - Natur - Sinnlichkeit Karl Alber Freiburg München <num> ISBN <num>-<num>-<num>-<num> Band II Rationalität - Welt - Vernunft Karl Alber FreiburgMünchen <num> ISBN <num>-<num>-<num>-<num>
David F Noble Maschinenstürmer oder die komplizierten Beziehungen der Menschen zu ihren Maschinen Wechselwirkung-Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>
Erich Ribolits Die Arbeit hoch
Berufspädagogische Streitschrift wider die Totalverzweckung des Menschen im Post-Fordismus
Profil München Wien <num> ISBN <num>-<num>-<num>-<num>
Holger Schatz Arbeit als Herrschaft
Die Krise des Leistungsprinzips und seine neoliberale Rekonstruktion
<num> ISBN <num>-<num>-<num>-<num>
Helmuth Schneider u a Geschichte der Arbeit
Vom Alten Ägypten bis zur Gegenwart
Kiepenheuer
Witsch Köln <num> ISBN <num>-<num>-<num>-<num>
Eberhard Straub Vom Nichtstun
Leben in einer Welt ohne Arbeit
wjs-Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>
Wieland Jäger und Kurt Röttgers Hrsg Sinn von Arbeit
Soziologische und wirtschaftsphilosophische Betrachtungen
VS Verlag Wiesbaden <num>
Susanne Hartard Axel Schaffer Carsten Stahmer Hrsg Die Halbtagsgesellschaft
Konkrete Utopie für eine zukunftsfähige Gesellschaft
Nomos Verlag Baden-Baden <num> ISBN <num>-<num>-<num>-<num>
Manfred Füllsack Arbeit UTB Reihe NR<num>
<num> ISBN <num>-<num>-<num>-<num>-<num>
S Kinkel M Friedewald B Hüsing u a Arbeiten in der Zukunft Strukturen und Trends der Industriearbeit Studien des Büros für Technikfolgen-Abschätzung beim Deutschen Bundestag <num>
Edition Sigma Berlin <num>
Heinz-J
Bontrup Arbeit und Kapital
Wirtschaftspolitische Bestandsaufnahme und Alternativen
In Johannes Rehm Hans G Ulrich Hrsg Menschenrecht auf Arbeit
Sozialethische Perspektiven
Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Zeitschriften und Jahrbücher
Archiv für die Geschichte des Widerstandes und der Arbeit
Labor History Routledge
Weblinks
Themen Neue Arbeitswelt und Geschichte der Arbeit
Online-Version von Aus Politik und Zeitgeschichte der Bundeszentrale für politische Bildung
Oliver Kloss
In Bernd Gehrke Wolfgang Rueddenklau Hrsg Das war doch nicht unsere Alternative Verlag Westfälisches Dampfboot Münster <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Peter-Paul Bänziger
in
Zeithistorische ForschungenStudies in Contemporary History <num> <num> S <num>-<num>
Archiv Bilder der Arbeit Archiv zur Darstellung der Arbeit in der bildenden Kunst
Museen
Museum der Arbeit in Hamburg Museum Arbeitswelt in Steyr
Anmerkungen
Einzelnachweise
Sabine Eylert Ursula Bertels Ursula Tewes Hrsg Von Arbeit und Menschen Überraschende Einblicke in das Arbeitsleben fremder Kulturen Waxmann Münster New York <num> Einleitung von Christiana Lütges S <num>-<num> insb <num>-<num> Tripaliare bedeutete ursprünglich jemanden auf dem trepalium zu foltern dieses wurde erstmals im <num> Jahrhundert erwähnt als aus drei hölzernen Stöcken bestehendes Pfählungsinstrument Im zwölften Jahrhundert war mit dem Wort sowohl im Französischen als auch im Spanischen eine schmerzhafte Erfahrung gemeint die ein Mensch ertragen muss erst im <num> Jahrhundert wurde es möglich das Verb trabajar bei der Arbeit als gleichbedeutend mit laborar und sudar zu verwenden - Ivan Illich Selbstbegrenzung Eine politische Kritik der Technik Übersetzung Ylva Eriksson-Kuchenbuch Becksche Verlagsbuchhandlung München <num> ISBN <num>-<num>-<num>-<num> S <num> Originaltitel Tools for Conviviality Harper and Row New York <num> Arne Eggebrecht Jens Flemming Gert Meyer Achatz von Müller Alfred Oppolzer Akoš Paulinyi Helmuth Schneider Geschichte der Arbeit Vom Alten Ägypten bis zur Gegenwart Kiepenheuer
Witsch Köln <num>Xenophon Oikonomikós <num>Aristoteles Politik <num> b <num> ffDe officiis <num>grundeinkommensblogblogspotcom
Der aktuelle Beschäftigungsoptimismus in historischer Perspektive <num> November <num>
Website des Theoriemagazins
wwwanarchismusat
krisisorg
Die atomare Masseneinheit Einheitenzeichen u für
unified atomic mass unit veraltet amu für
atomic mass unit ist eine Maßeinheit der Masse
Ihr Wert ist auf
der Masse eines Atoms des Kohlenstoff-Isotops <num>C festgelegt
Die atomare Masseneinheit ist zum Gebrauch mit dem Internationalen Einheitensystem SI zugelassen und eine gesetzliche Maßeinheit
Sie wird bei der Angabe nicht nur von Atom- sondern auch von Molekülmassen verwendet
In der Biochemie in den USA auch in der organischen Chemie wird die atomare Masseneinheit auch als Dalton bezeichnet Einheitenzeichen Da benannt nach dem englischen Naturforscher John Dalton
Die so gewählte atomare Masseneinheit hat die praktisch nützliche Eigenschaft dass alle bekannten Kern- und Atommassen nahe bei ganzzahligen Vielfachen von u liegen die Abweichungen betragen in allen Fällen weniger als <num> u Die betreffende ganze Zahl heißt Massenzahl des Kerns oder Atoms und ist gleich der Anzahl der Nukleonen im Kern
Definition
<num> u ist definiert als ein Zwölftel der Masse eines isolierten Atoms des Kohlenstoff-Isotops <num>C im Grundzustand
Der aktuell empfohlene Wert ist<ref nameuinkg> Wert für u in der Einheit kg
Die eingeklammerten Ziffern bezeichnen die Unsicherheit in den letzten Stellen des Wertes diese Unsicherheit ist als geschätzte Standardabweichung des angegebenen Zahlenwertes vom tatsächlichen Wert angegeben<ref><ref> Wert für u in der Einheit MeVc<sup><num><sup>
Die eingeklammerten Ziffern bezeichnen die Unsicherheit in den letzten Stellen des Wertes diese Unsicherheit ist als geschätzte Standardabweichung des angegebenen Zahlenwertes vom tatsächlichen Wert angegeben
bzw wegen der Masse-Energie-Äquivalenz
Die Umrechnung in die SI-Einheit Kilogramm ergibt
bzw
Da der Kern des <num>C-Atoms <num> Nukleonen enthält ist die Einheit u annähernd gleich der Masse eines Nukleons also eines Protons oder Neutrons
Deshalb entspricht der Zahlenwert der Atommasse in u annähernd der Massenzahl oder Nukleonenzahl also der Zahl der schweren Kernbausteine des Atoms
Frühere Definitionen
Bis <num> war die atomare Masseneinheit definiert als
der Masse eines Sauerstoff-Atoms
Dabei bezogen sich die Chemiker auf die durchschnittliche Masse eines Atoms im natürlich vorkommenden Isotopengemisch des Elements O die Physiker aber auf die Masse des Atoms des Hauptisotops <num>O
Die Differenz zwischen der chemischen Definition und der physikalischen Definition war Anlass eine vereinheitlichte Definition einzuführen
Über die Verhandlungen in den zuständigen Gremien wird berichtet dass die Chemiker zunächst nicht bereit waren auf die Definition der Physiker mit <num>O einzuschwenken da dies erhebliche Verluste beim Verkauf von chemischen Substanzen zur Folge gehabt hätte
Schließlich überzeugten die Physiker die Chemiker mit dem Vorschlag <num>C als Basis zu nehmen wodurch der Unterschied zur chemischen Definition nicht nur viel geringer war sondern auch in die richtige Richtung ging und sich positiv auf die Verkaufserlöse auswirken würde
Zwischen dem neuen und den beiden veralteten Werten der Einheit gilt die Beziehung
Die Differenz zwischen der alten physikalischen und der heutigen Definition ist auf den Massendefekt zurückzuführen der bei <num>O höher ist als bei <num>C
Verwendung
In der deutschen Übersetzung der Broschüre des Internationalen Büros für Maß und Gewicht werden die vereinheitlichte atomare Masseneinheit und das Dalton synonym genannt In den gesetzlichen Regelungen der EU-Richtlinie <num><num>EWG für die Staaten der EU und im Bundesgesetz über das Messwesen in der Schweiz kommt der Ausdruck Dalton nicht vor
Das Dalton kann als besonderer Name für die atomare Masseneinheit betrachtet werden aber die Bezeichnung Dalton ist weder gesetzlich noch DIN-normgerecht
Begrifflich gibt es Überlappungen zur molaren Masse sowie zur Molekülmasse die sich in der Praxis deutlich zeigen So wird etwa die Masse großer Moleküle wie Proteine DNA und anderer Biomoleküle mit der atomaren Masseneinheit - meist in Kilodalton - charakterisiert da es zahlenmäßig keine Unterschiede zur Angabe in kgmol gibt
Sowohl für die atomare Masseneinheit als auch für das Dalton ist die Verwendung von Vorsätzen für dezimale Vielfache und Teile zulässig
Gebräuchlich sind das Kilodalton <num> kDa
<num> Da sowie das Megadalton <num> MDa
<num><num> Da
Beziehung zur molaren Masse
Bis zur Neudefinition der SI-Basiseinheiten im Jahr <num> war das Mol als die Stoffmenge definiert die aus ebenso vielen Einzelteilchen besteht wie Atome in <num> Gramm <num>C enthalten sind
Durch diese Definition der atomaren Masseneinheit und des Mols über dasselbe Atom ein Atom <num>C hatte eine Masse von <num> u ein Mol <num>C hatte eine Masse von <num> g ergab sich für die Masse eines Teilchens in u und dessen molare Masse in gmol exakt der gleiche Zahlenwert
Beispiel Acetylsalicylsäure Masse eines Moleküls <num> u molare Masse <num> gmol
Die Avogadro-Konstante NA also die Anzahl Teilchen pro Mol musste nach dieser Definition experimentell bestimmt werden und war mit einer Messunsicherheit behaftet
Da seit <num> nunmehr der Wert für NA exakt festgelegt ist und somit die Zahl der Teilchen in einem Mol nicht mehr über die Masse des <num>C-Atoms bestimmt wird hat ein Mol <num>C nicht mehr exakt die Masse <num> g allgemein haben nun die Masse eines Teilchens in u und die molare Masse in g nicht mehr exakt denselben Zahlenwert
Beispiele
Ein Kohlenstoffatom des Isotops <num>C hat definitionsgemäß die Masse <num> u
Ein Wasserstoffatom des Isotops <num>H hat die Masse <num> <num> <num> u
Ein Molekül des bekannten Wirkstoffes Acetylsalicylsäure Aspirin hat eine Masse von <num> u
Ein Molekül des kleinen Peptidhormons Insulin hat eine Masse von <num> u
Ein Molekül des Proteins Aktin eines der häufigsten Proteine in Eukaryoten hat eine Masse von ungefähr <num> ku
Einzelnachweise
aufgrund der EU-Richtlinie <num><num>EWG in den Staaten der EU bzw dem Bundesgesetz über das Messwesen in der Schweiz Aaldert Wapstra zitiert nach G Audi The History of Nuclidic Masses and of their Evaluation IntJMass SpectrIon Process <num> <num> <num>-<num> arxiv
Als Anglizismus bezeichnet man einen sprachlichen Ausdruck der aus dem Englischen in eine andere Sprache eingeflossen ist
Betroffen davon sind alle Bereiche eines Sprachsystems von der Lautung über die Formenlehre Syntax Semantik bis zum Wortschatz sowie die Bereiche Sprachgebrauch und Sprachebene Fachsprache Alltagssprache Slang und anderes
Findet die Übernahme Akzeptanz von Seiten der Sprachgemeinschaft werden die Ausdrücke als Fremd- und Lehnwort bzw als neue Bedeutung eines deutschen Wortes oder als neue Satzkonstruktion übernommen
Werden die englischen Einflüsse nicht allgemein akzeptiert etwa weil sie auf einen Jargon oder die Jugendsprache beschränkt sind spricht man von Neudeutsch oder abwertend von Denglisch
Im Laufe des Generationenwechsels kann sich sowohl diese Wertung als auch der Gebrauch von Anglizismen ändern
Insbesondere in der Jugendsprache verschwinden viele Ausdrücke mit der nächsten Generation wieder da sie nicht mehr als neu und der Jugend vorbehalten empfunden werden
Der Begriff Anglizismus umfasst alle englischen Sprachvarietäten Einflüsse speziell aus dem britischen Englisch werden auch Britizismen und solche aus dem amerikanischen Englisch Amerikanismen genannt
Anglizismen in der deutschen Sprache
Erscheinungsformen
Im Deutschen treten Anglizismen am häufigsten auf der lexikalischen Ebene in Erscheinung
Man kann folgende Phänomene unterscheiden
Wortentlehnungen Übernahme englischer Lexeme die unterschiedlich stark an das Laut- Schrift- und Grammatiksystem der aufnehmenden Sprache angepasst werden
So gilt etwa die Mehrzahl die Killer und der Genitiv des Internets als an das deutsche Flexionssystem angepasst
Auch weitergehende Veränderungen wie Kürzungen kommen vor etwa bei fesch aus engl fashionable
Lehnübersetzungen Eins-zu-eins-Übersetzungen der Bestandteile des fremden Wortes wie zum Beispiel brainwashing
Gehirnwäsche
Lehnübertragungen Übersetzung der Idee hinter der Bildung des fremden Wortes zum Beispiel skyscraper
Wolkenkratzer nicht Himmelskratzer wie es bei einer Lehnübersetzung zu erwarten wäre
Lehnbedeutungen Übernahme des Bedeutungsspektrums des fremden Wortes von dem Teilbedeutungen bereits bei einem deutschen Wort zu finden sind zum Beispiel deutsch realisieren im Sinne von etwas bemerken sich einer Tatsache bewusst sein nach englisch realizerealise etwas verwirklichen etwas bemerken sich einer Tatsache bewusst sein keine sinnliche Wahrnehmung im Gegensatz zu to notice
Ein weiteres Beispiel ist der Held im Sinne des Theaterhelden die Übernahme aus dem Bedeutungsspektrum von hero
Scheinanglizismen Wortschöpfungen innerhalb einer anderen als englischen Sprachgemeinschaft mit englischen Sprachelementen darunter im Deutschen Handy Basecap oder Service Point Oft existieren solche Wörter oder Wortgruppen auch im Englischen jedoch mit einer anderen Bedeutung falscher Freund
Das Wort Oldtimer etwa benennt im Deutschen als Scheinanglizismus ein altes Auto engl vintage car veteran car oder classic car während es im Englischen generell einen alten Menschen vergleichbar unserem scherzhaft verwendeten Oldie bezeichnet
Weitere Übernahmeerscheinungen sind auf anderen Sprachebenen zu verzeichnen
Lehnsyntax Verwendung von englischer Syntax die im Deutschen nicht üblich ist
Formenbildung Ebenfalls eine Form des Anglizismus ist die Übernahme englischer Konjugationsformen bei Verwendung ursprünglich englischer Verben in deutschen Sätzen
Das Partizip Perfekt von Verben wird manchmal mit der Endung -ed gebildet geprinted Dieselbe Endung dringt dann - wohl wegen der Ähnlichkeit zur deutschen Endung -et - vereinzelt auch in die Präsensbildung ein er printed
Orthografie und Interpunktion Benutzung der englischen statt der deutschen Schreibung zum Beispiel Verwendung der englischen Transkription aus nichtlateinischen Schriften wie der kyrillischen oder der arabischen
Schreibung mit c in zahlreichen aus dem oder über das Lateinische oder Griechische entlehnten Wörtern wo dieses im neueren Deutsch meist durch k oder z wiedergegeben wird so etwa
Holocaust
statt Holokaust
Die Verwendung der englischen Kommasetzung zu den Anglizismen
So gibt es im Englischen beispielsweise keine Kommas vor that-dass- und anderen Nebensätzen wohl aber innerhalb von Hauptsätzen z B
am Satzanfang nach Adverbialen
Die eindeutige Klassifizierung als Anglizismus ist dabei schwierig
Leerzeichen in Komposita Industrie Museum vielleicht auch wieder zunehmende Verwendung von Bindestrichen Industrie-Museum
Aussprache nicht-englischer Wörter oder Namen auf Englisch durch Deutsche zum Beispiel der französischen Wörter
Pointe Relais
und
Revirement der ersten Silbe der Wörter Journalist und Journalismus mit d vorweg wegen Häufigkeit vom Duden anerkannt oder des flämischen Ortsnamens
Waterloo Hierher gehört auch die englische Aussprache der Abkürzung IT für
Informationstechnik sogar im deutschen Hörfunk und Fernsehen
Missverstehen eines gesprochenen französischen Wortes als eines englischen Sie hat ein Fabel statt Faible für die Nation Ebenso Ein Fabel für Regenwürmer soll Charles Darwin gehabt haben
Anzahl und Häufigkeit
Sprachwissenschaftliche Untersuchungen der Universität Bamberg stellen anhand von Material aus der Zeitung Die Welt eine Zunahme von Anglizismen in der deutschen Sprache fest So hat sich von <num> bis <num> die Verwendung von Anglizismen
bei Substantiven verdoppelt
die Anzahl der Verben ebenfalls zugenommen
auch Adjektive sind häufiger geworden sterben jedoch auch schnell wieder aus
Entgegen der allgemeinen Annahme dass es beim Sprachkontakt vorwiegend zur Übernahme von Substantiven komme wurden im untersuchten Zeitraum insgesamt etwa gleich viele Wörter aus jeder dieser drei Wortarten vom Englischen ins Deutsche entlehnt allerdings bleiben die Substantive durchschnittlich länger im Gebrauch erhalten
Die Anzahl der Anglizismen hat zugenommen ebenso die Häufigkeit mit der diese verwendet werden
Klassifiziert man die Anglizismen nach Bereichen lässt sich feststellen dass der Bereich Wirtschaft am stärksten gewachsen ist vor allem im Marketing und Vertrieb siehe GemlLauer <num>
Einzige Ausnahme bildet der Bereich Wissenschaft und Technik in welchem eine Abnahme um den Faktor <num> zu verzeichnen ist
Insgesamt lässt sich festhalten dass der Gebrauch von Anglizismen in zehn Jahren um den Faktor <num> zugenommen hat
Hingegen hat die Entlehnungshäufigkeit im Vergleich zum Zeitraum <num>-<num> abgenommen
Das heißt es werden mehr Anglizismen verwendet die Geschwindigkeit der Übernahme hat aber abgenommen
Der Grund hierfür könnte ein Sättigungsprozess sein
In einer weiteren Untersuchung wurde ein großes Textkorpus der Gegenwart <num>-<num> mit insgesamt <num> Lemmata ausgewertet darunter wurden <num>
<num>
Anglizismen festgestellt
Das Textkorpus hat einen Umfang von rund <num> Millionen Token
einzelne Wortformen darunter <num>
<num>
Anglizismen Von den <num> Anglizismen sind <num> <num>
<num> Token
<num>
Substantive <num> <num>
<num> Token
<num>
Adjektive <num> <num>
<num> Token
<num>
Verben und <num> <num>
<num> Token
<num>
Adverbien
Entwicklung der Anglizismen im Deutschen
Angaben dazu wann welcher Anglizismus ins Deutsche gelangt ist kann man vor allem aus Herkunftswörterbüchern
etymologischen Wörterbüchern gewinnen
Sie haben den Nachteil dass sie nur einen Kernbestand des Wortschatzes enthalten und zwar vor allem den Teil der etymologisch besonders interessant ist
Es stellt sich also die Frage ob der Trend der Entlehnungen der in einem solchen Wörterbuch nachweisbar ist auch für die Gesamtsprache repräsentativ ist
Dies muss man sich bewusst machen mangels anderer Möglichkeiten bleibt aber nichts anderes übrig wenn man sich eine Vorstellung von dem Verlauf der Entlehnungen machen will
Eine solche Untersuchung hat Körner am Beispiel von Duden
Das Herkunftswörterbuch <num>
durchgeführt indem sie alle Entlehnungen erfasste für die nach Auskunft dieses Wörterbuchs festgestellt werden kann in welchem Jahrhundert sie aus welcher Sprache ins Deutsche gelangt sind
Speziell für die aus dem Englischen stammenden Entlehnungen kam Körner zu folgendem Ergebnis
Das Wörterbuch enthält <num> datierbare Stichwörter darunter <num> Entlehnungen Lehnwörter und Fremdwörter
Unter den Entlehnungen sind <num> datierbare Anglizismen
Man sieht dass diese Entlehnungen aus dem Englischen erst recht spät einsetzen und dann aber eine erhebliche Dynamik entwickeln
Im <num> Jahrhundert erreichen die Anglizismen <num>
des gesamten erhobenen Wortschatzes beziehungsweise <num>
der Entlehnungen
Anpassung an deutsche Sprachgewohnheiten
Besonders schon vor längerer Zeit entlehnte Wörter haben eine Anpassung der Schreibweise erfahren etwa
Keks
gegenüber älterem Cakes
Bei vor allem über den schriftlichen Verkehr übernommenen Anglizismen kann sich die Aussprache bei gleichbleibendem Schriftbild nach deutschen Aussprachegewohnheiten richten so wird
Jute
heute im Deutschen gewöhnlich
ausgesprochen während ältere Wörterbücher noch die Aussprache
verzeichnen
Kritik und Kontroversen
Eine repräsentative Umfrage
über die Verständlichkeit von zwölf gebräuchlichen englischen Werbeslogans für deutsche Kunden ergab im Jahr <num> dass einige der Slogans von weniger als <num>
der Befragten verstanden wurden
Acht der zwölf untersuchten Unternehmen hätten ihre Werbeslogans seitdem geändert
<num> störten sich in einer Umfrage der Gesellschaft für deutsche Sprache <num>
der Befragten an Lehnwörtern aus dem Englischen
Die Ablehnung war in den Bevölkerungsgruppen am größten die Englisch weder sprechen noch verstehen konnten <num>
Ablehnung bei der Gruppe der über <num>-Jährigen <num>
Ablehnung bei ostdeutschen Umfrageteilnehmern
Die Entwicklung des Englischen zur lingua franca im <num> Jahrhundert beeinflusst die meisten Sprachen der Welt
Mitunter werden Worte ersetzt oder bei Neuerscheinungen ohne eigene Übersetzung übernommen
Diese Entwicklung wird vor allem dann skeptisch betrachtet wenn es genügend Synonyme in der Landessprache gibt
Kritiker merken auch an es handle sich häufig beispielsweise bei Handy im Deutschen um Scheinanglizismen
Mitunter wird auch eine unzureichende Kenntnis der englischen Sprache für die Vermischung und den Ersatz bestehender Worte durch Scheinanglizismen verantwortlich gemacht
So sprechen einer Studie der GfK zufolge nur <num> Prozent der deutschen Arbeitnehmer verhandlungssicher Englisch
In der Gruppe der unter <num>-Jährigen bewerten jedoch über <num> Prozent ihre Englischkenntnisse als gut bis exzellent Für bessere Sprachkenntnisse könne demzufolge effizienterer Englischunterricht beitragen und statt der Ton-Synchronisation von Filmen und Serien solle eine Untertitelung der englischsprachigen Originale mit deutschem Text erfolgen
Dies würde zugleich zu einer besseren Abgrenzung zwischen den Sprachen und einer Wahrung deutscher Sprachqualität beitragen
Im Dezember <num> forderte der Europapolitiker Alexander Graf Lambsdorff neben Deutsch die englische Sprache als Verwaltungs- und später als Amtssprache in Deutschland zuzulassen um die Bedingungen für qualifizierte Zuwanderer zu verbessern den Fachkräftemangel abzuwenden und Investitionen zu erleichtern Einer repräsentativen YouGov-Umfrage zufolge würden es <num> Prozent der Deutschen begrüßen wenn die englische Sprache in der gesamten Europäischen Union den Status einer Amtssprache erlangen würde
Ähnliche Kritik wie gegenüber den Anglizismen traf bereits ab Ende des <num> Jahrhunderts die aus dem Französischen Lateinischen oder Griechischen stammenden Begriffe
Vereine wie der Allgemeine Deutsche Sprachverein versuchten im Rahmen des deutschen Sprachpurismus diese Begriffe durch deutsche zu ersetzen
So sind französische lateinische oder griechische Fremdwörter durch deutsche Wortschöpfungen ersetzt worden z B
Fahrkarte für Billet Abteil für Coupé und Bahnsteig für Perron
Im Postwesen wurden auf Geheiß Bismarcks vom Generalpostmeister Heinrich von Stephan über <num> französischsprachige Begriffe durch deutsche Neuschöpfungen ersetzt
Zwar war die damalige Öffentlichkeit empört und man verhöhnte ihn als Generalsprachmeister trotzdem sind Begriffe wie eingeschrieben postlagernd und Empfangsschein heute in den allgemeinen Sprachgebrauch übergegangen und ersetzen die Fremdwörter rekommandiert poste restante und Rezepisse
Viele Unternehmen setzen Anglizismen in Stellenangeboten bzw -beschreibungen ein
Kritiker vermuten dass weniger attraktive Stellen dadurch aufgewertet werden sollen Häufig verwendete Begriffe sind Area-Manager weniger als der klassische Abteilungsleiter Facility-Manager Hausmeister
Key Account Manager
Betreuer wichtiger Kunden oder
Case Manager
ein Fallbearbeiter siehe Fallmanagement
Um diese Entwicklung zu karikieren wird gelegentlich der Euphemismus WC-Manager Klomann-frau genannt In Frankreich stoßen Lehnwörter und Anglizismen noch stärker auf Kritik und sollen auch durch gesetzgeberische Maßnahmen wie die Loi Toubon eingedämmt werden
Eine aktive Sprachpolitik wie sie unter anderem in Frankreich und Island betrieben wird um eine Anreicherung der Sprache mit Anglizismen zu unterbinden findet in Deutschland seit Mitte des <num> Jahrhunderts nicht mehr statt
Der Sprachwissenschaftler Rudolf Hoberg sah <num> keine Bedrohung durch Anglizismen
Die deutsche Sprache habe schon immer englische Ausdrücke aufgenommen Nach der letzten Duden-Ausgabe haben wir etwa <num> Prozent Anglizismen aber <num> Prozent andere Fremdwörter über die sich die Leute meistens gar nicht aufregen Ebenso lehnt er gesetzliche Regelungen wie Sprachquoten in Frankreich oder Verfassungsänderungen wie in Österreich ab die keine Erfolge zeigten Der Germanist Karl-Heinz Göttert nannte die Aufregung über Anglizismen komisch Sie machen weniger als zwei Prozent des deutschen Wörterschatzes aus
Da gab und gibt es ganz andere Fremdwortschwemmen
Das Englische selbst hat im Mittelalter ein Drittel aus dem Französischen entlehnt
Und die japanische Sprache hat aus dem Chinesischen <num> Prozent übernommen Sie seien ein Beweis dafür dass Nehmersprachen kreativ und nicht knechtisch mit dem Einfluss der Gebersprachen umgehen Er wandte sich gegen eine Leitkultur und kritisierte den Sprachpurismus mit den Worten Schon Jakob Grimm hat sich deshalb gegen den ärgerlichen Purismus gewendet
Es wäre besser der Verein Deutsche Sprache würde sich auf die Grimmsche Tradition besinnen statt einen Grimm-Preis für Verdienste beim Anglizismen-Kampf zu vergeben
Auch rechtsextreme Organisationen wie die NPD stören sich oft an Anglizismen und versuchen beispielsweise das nicht allgemein anerkannte Wort Weltnetz statt Internet zu etablieren
Anglizismen in der französischen Sprache
Siehe dazu Loi Toubon
Siehe auch
Internationalismus Sprache
Literatur
Broder Carstensen Ulrich Busse Anglizismen-Wörterbuch der Einfluss des Englischen auf den deutschen Wortschatz nach <num> De Gruyter Berlin
New York NY <num> ISBN <num>-<num>-<num>-<num>
Peter Eisenberg Anglizismen im Deutschen
In Deutsche Akademie für Sprache und Dichtung Union der deutschen Akademien der Wissenschaften Hrsg Reichtum und Armut der deutschen Sprache
Erster Bericht zur Lage der deutschen Sprache
De Gruyter Berlin
Boston MA <num> Seiten <num>-<num>
ISBN <num>-<num>-<num>-<num>-<num>
Cristiano Furiassi und Henrik Gottlieb Hrsg Pseudo-English - Studies on False Anglicisms in Europe De Gruyter Berlin
Boston
München <num> ISBN <num>-<num>-<num>-<num>-<num>
Richard Glahn Der Einfluss des Englischen auf gesprochene deutsche Gegenwartssprache
Eine Analyse öffentlich gesprochener Sprache am Beispiel von Fernsehdeutsch
<num> durchgesehene Aufl Peter Lang Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num>
Manfred Görlach Dictionary of European Anglicisms Oxford <num> ISBN <num>-<num>-<num>-<num>
Wolfgang Müller-Hasemann Das Eindringen englischer Wörter ins Deutsche ab <num> In Karl-Heinz Best Jörg Kohlhase Hrsg Exakte Sprachwandelforschung edition herodot Göttingen <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
Rudolf Muhr Anglizismus In Gert Ueding Hrsg Historisches Wörterbuch der Rhetorik
WBG Darmstadt <num>ff Band <num> <num> Sp <num>-<num>
Nicole Plümer Anglizismus - Purismus - Sprachliche Identität
Eine Untersuchung zu den Anglizismen in der deutschen und französischen Mediensprache
Peter Lang Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num> Dissertation Uni Münster Westfalen philosophische Fakultät <num>
Peter Schlobinski Anglizismen im Internet in Networx Nr <num> <num> Online PDF kostenlos <num> Seiten <num> KB
Jan Georg Schneider Von free-floatendem Kapital Hardlinern und Instructions
Linguistische Anmerkungen zur populären Anglizismenkritik
In Verein Lingua et opinio e V
LeO Hrsg Studentische Zeitschrift für Sprache und Kommunikation <num> Dezember <num> online
Wolfgang Schweickard Glanz und Elend der Sprachpflege der Umgang mit Anglizismen in Frankreich Italien und Deutschland in Wolfgang Dahmen u a Hrsg Englisch und Romanisch
Romanistisches Kolloquium XVIII
Tübinger Beiträge zur Linguistik Band <num> Narr Tübingen <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num>
Stefan Zenklusen Leitsprache Anglotumbdeutsch
In ders Im Archipel Coolag
wvb Berlin <num> ISBN <num>-<num>-<num>-<num> gekürzt in Zeitschrift für kritische Theorie Nr <num><num> Jahrgang <num> S <num>f ISBN <num>-<num>-<num>-<num>-<num>
Weblinks
Fehlende Sprachloyalität
Tatsachen und Anmerkungen zur jüngsten Entwicklung des öffentlichen Sprachbewusstseins in Deutschland
Linguistische Anmerkungen zu einer populären Anglizismen-Kritik PDF <num> kB Thomas Niehr Heinrich-Heine-Universität Düsseldorf <num>
Anglizismen sind das neue Imponier-Deutsch zeitde <num> Infoportal zu Gebrauch Einfluss und Kritik private Seite
Einzelnachweise
Wolfgang Pfeifer et al Etymologisches Wörterbuch des Deutschen <num> Aufl Berlin <num> p <num> Dieter HerbergMichael KinneDoris Steffens Neuer Wortschatz Neologismen der <num>er Jahre im Deutschen BerlinNew York <num> Broder CarstensenUlrich Busse Anglizismen-Wörterbuch der Einfluss des Englischen auf den deutschen Wortschatz nach <num> Band <num> A-E BerlinNew York <num> p <num> Stephanie Bohmann Englische Elemente im Gegenwartsdeutsch der Werbebranche Tectum Verlag <num> ISBN <num>-<num>-<num>-<num>-<num> Frank Puscher Oberflächliche Fehler In ct <num><num> S <num> zweiter Absatz Sie wollen nicht gewertet sondern gevoted werden Sie möchten dass man sie diggt ihnen followed Britta Baas und Bettina Röder in Publik-Forum <num><num> Seite <num> Annett Stein im General-Anzeiger Bonn vom <num> Dezember <num> Journal Seite <num> Svetlana Burmasova
PDF <num> MB in Beiträge zur Linguistik Band <num> University of Bamberg Press Bamberg <num> a S <num>ff b S <num> c S <num> Peter Eisenberg Anglizismen im Deutschen In Deutsche Akademie für Sprache und Dichtung Union der deutschen Akademien der Wissenschaften Hrsg Reichtum und Armut der deutschen Sprache Erster Bericht zur Lage der deutschen Sprache De Gruyter BerlinBoston <num> Seiten <num>-<num> Bezug Seite <num> ISBN <num>-<num>-<num>-<num>-<num> Peter Eisenberg Anglizismen im Deutschen In Deutsche Akademie für Sprache und Dichtung Union der deutschen Akademien der Wissenschaften Hrsg Reichtum und Armut der deutschen Sprache Erster Bericht zur Lage der deutschen Sprache De Gruyter BerlinBoston <num> Seiten <num>-<num> Bezug Seite <num> ISBN <num>-<num>-<num>-<num>-<num> Duden Das Herkunftswörterbuch Bibliographisches Institut MannheimLeipzigWienZürich <num> ISBN <num>-<num>-<num>-<num> Helle Körner Zur Entwicklung des deutschen Lehn-Wortschatzes In Glottometrics <num> <num> Seite <num>-<num> Tabelle für die Anglizismen Seite <num> weitere Angaben <num>f Der Prozess verläuft wie bei den Entlehnungen aus anderen Sprachen auch gesetzmäßig nach den Piotrowski-Gesetz Körners Beitrag enthält ähnliche Tabellen zur Entwicklung des Gesamtwortschatzes und der Entlehnungen aus dem Lateinischen Französischen Niederdeutschen Italienischen Griechischen Niederländischen Slawischen Spanischen und Rotwelschen Weitere Auswertungen ganzer etymologischer Wörterbücher Karl-Heinz Best Gabriel Altmann Untersuchungen zur Gesetzmäßigkeit von Entlehnungsprozessen im Deutschen In Folia Linguistica Historica <num> <num> Seite <num>-<num> zu Duden Etymologie <num> und Katharina Ternes Entwicklungen im deutschen Wortschatz In Glottometrics <num> <num> Seite <num>-<num> zu Kluge Etymologisches Wörterbuch der deutschen Sprache <num> Auflage <num> Zusammenfassung der Endmark-Studie Studie der Gesellschaft für deutsche Sprache
Deutsche sprechen schlecht Englisch Studie der GfK Die Zeit <num> Juni <num> Sprachen lernen Fernsehen auf Englisch Die Zeit <num> April <num> Berliner Behörden machen es internationalen Start-ups nicht leicht Tagesspiegel <num> April <num> Englisch muss unsere Verwaltungssprache werden Die Welt Kommentar von Alexander Graf Lambsdorff <num> Dezember <num> Umfrage Mehrheit der Deutschen für Englisch als zweite Amtssprache YouGov Meinungsforschungsinstitut <num> August <num> Ludwig Reiners Stilkunst Ein Lehrbuch deutscher Prosa <num> Auflage CHBeck München <num> S <num> ISBN <num>-<num>-<num>-<num>
RP online vom <num> Oktober <num>
Spiegel Online vom <num> November <num>
NPD-Blog <num> März <num>
Die Welt <num> August <num> booksgooglede
DateiAstronomermoonjpg DateiJohannesVermeer-TheAstronomer<num>jpg DateiGalileoarp<num>pixjpg Ein Astronom von
ástron Stern Gestirn und νόμος nómos Gesetz ist eine meist akademisch gebildete Person die sich wissenschaftlich mit der Astronomie beschäftigt
Haupttätigkeit der Astronomen
Beschränkt man den Begriff Astronom auf jene Wissenschaftler die sich hauptberuflich der Astronomie widmen dann sind meist zwei der folgenden Tätigkeiten Gegenstand des Berufs
wissenschaftliche Forschung auf dem Gebiet Astronomie insbesondere in der Astrophysik Astrometrie Kosmologie oder im Bereich des Planetensystems beziehungsweise der Raumfahrt
Die Arbeit kann im Beobachten bestehen in deren Analyse
Lehrtätigkeit an einer Universität als Hochschulprofessor oder -assistent
Entwicklung von Messinstrumenten oder Computerprogrammen
Leitung undoder Verwaltung von Einrichtungen für Forschung und Entwicklung bzw von großen Projekten - etwa bei der ESA oder NASA
Der Beruf des Fachastronomen setzt im Regelfall ein Hochschulstudium der Astronomie oder verwandter Naturwissenschaften voraus etwa ein Diplom der Physik oder Astronomie nur in Österreich manchmal auch Studienabschlüsse aus Mathematik Geodäsie Aeronautik und anderen
Das Verfassen einer Dissertation schließt sich in den meisten Fällen an denn die abgeschlossene Promotion gilt oft als Einstellungsvoraussetzung
Gewandeltes Berufsbild
Das Berufsbild des Astronomen hat sich in den letzten Jahrzehnten stark gewandelt
In der Vergangenheit beobachteten Astronomen überwiegend den Himmel mittels optischer Teleskope an Sternwarten
Heute arbeiten die meisten Astronomen an sehr spezialisierten Fragestellungen und überwiegend am Computer
Sie verwenden elektromagnetische Signale aus allen Wellenlängenbereichen von der kurzwelligen Gammastrahlung bis zu den längsten Radiowellen
Viele Messdaten werden auch über das Internet verbreitet - insbesondere bei regelmäßigen internationalen Messkampagnen wie im IVS - beziehungsweise vom Netz übernommen
Daher arbeiten Astronomen heute kaum mehr am Fernrohr selbst sondern nur einen vergleichsweise kurzen Teil ihrer Arbeitszeit in den Kontrollräumen der Sternwarten
Die dort gewonnenen Daten werden meist außerhalb der Nachtdienste ausgewertet und aufbereitet
Immer mehr gewinnt das so genannte service mode observing Beobachtung auf Abruf an Bedeutung es werden nur Beobachtungsziel und -art angegeben werden während die Beobachtungen unabhängig oder automatisiert an den Teleskopen beziehungsweise von Erdsatelliten durchgeführt werden
Fach- und Amateurastronomen
Da viele Studenten des Faches später auf anderen Gebieten arbeiten hängt es von ihrem Selbstverständnis ab ob sie sich auch weiterhin als Astronom bezeichnen
Inwieweit wissenschaftlich tätige Amateurastronomen als Astronomen im eigentlichen Sinn zu nennen sind ist ebenfalls offen
Besonders in früheren Jahrhunderten ist eine Trennung zwischen Fachastronom und Amateur wenig zweckmäßig wie etwa das Beispiel von Wilhelm Olbers zeigt
Da die Astronomie nach wie vor eine Wissenschaft ist die auch im professionellen Bereich von einzelnen und kleinen Forschungsgruppen geprägt ist haben auch Amateure mit der entsprechenden Begabung und Ausrüstung die Möglichkeit mitzuwirken
Amateure sind oft dort erfolgreich wo eine kontinuierliche Beobachtung notwendig ist aber wegen der Kosten durch Großteleskope kaum professionell machbar ist etwa die Asteroiden- und Kometenüberwachung oder auf dem Gebiet veränderlicher Sterne sowie der Astrometrie
Dienstzeit
Da Astronomen naturgemäß - wenn auch durch die moderne Beobachtungs- und Informationstechnik nicht mehr so ausgeprägt wie früher - ihre Tätigkeit in der Nacht ausüben erfordert die Arbeit eines Berufsastronomen klare Regelungen zur Dienstzeit
Die Zeiten des astronomischen Schlafmangels über die auch berühmte Astronomen manchmal in ihren Briefen oder Berichten geklagt haben sind allerdings größtenteils vorüber
Moderne Sternwarten sind meistens mit Technologien ausgerüstet die ein gewisses Maß an Fernbedienung erlauben oder sogar international anbieten wie z B
einige Observatorien auf Hawaii oder ESO-Sternwarten wie in Chile
Da visuelle Messungen oder Kontrollen nur mehr selten erforderlich sind und elektro-optische Sensoren grundsätzlich auch eine Funktionskontrolle über EDV oder über das Internet erlauben werden durchgehend nächtliche Arbeitszeiten zunehmend seltener
Siehe auch
Liste von Astronomen Liste von Astronominnen Physiker Mathematiker Geschichte der Astronomie Priesterastronom
Weblinks
Zeittafel der bedeutendsten Astronomen und ihrer Erkenntnisse
DateiAlan Turing az <num>-as évekbenjpg DateiAlan Turing signaturesvg Alan Mathison Turing OBE FRS
<num> Juni <num> in London
<num> Juni <num> in Wilmslow Cheshire war ein britischer Logiker Mathematiker Kryptoanalytiker und Informatiker
Er gilt heute als einer der einflussreichsten Theoretiker der frühen Computerentwicklung und Informatik
Turing schuf einen großen Teil der theoretischen Grundlagen für die moderne Informations- und Computertechnologie
Als richtungsweisend erwiesen sich auch seine Beiträge zur theoretischen Biologie
Das von ihm entwickelte Berechenbarkeitsmodell der Turingmaschine bildet eines der Fundamente der Theoretischen Informatik
Während des Zweiten Weltkrieges war er maßgeblich an der Entzifferung der mit der Enigma verschlüsselten deutschen Funksprüche beteiligt
Der Großteil seiner Arbeiten blieb auch nach Kriegsende unter Verschluss
Turing entwickelte <num> eines der ersten Schachprogramme dessen Berechnungen er mangels Hardware selbst vornahm
Nach ihm benannt sind der Turing Award die bedeutendste Auszeichnung in der Informatik sowie der Turing-Test zum Überprüfen des Vorhandenseins von künstlicher Intelligenz
Im März <num> wurde Turing wegen seiner Homosexualität die damals noch als Straftat verfolgt wurde zur chemischen Kastration verurteilt Turing erkrankte in Folge der Hormonbehandlung an einer Depression und starb etwa zwei Jahre später durch Suizid
Im Jahr <num> sprach der damalige britische Premierminister Gordon Brown eine offizielle Entschuldigung im Namen der Regierung für die entsetzliche Behandlung Turings aus und würdigte dessen außerordentliche Verdienste während des Krieges eine Begnadigung wurde aber noch <num> trotz einer Petition abgelehnt
Am Weihnachtsabend dem <num> Dezember <num> sprach Königin Elisabeth II posthum ein Royal Pardon Königliche Begnadigung aus
Leben und Wirken
Kindheit und Jugend
DateiAlan Turing Aged <num>jpg Alan Turings Vater Julius Mathison Turing war britischer Beamter beim Indian Civil Service
Er und seine Frau Ethel Sara geborene Stoney wünschten dass ihre Kinder in Großbritannien aufwachsen
Deshalb kehrte die Familie vor Alans Geburt aus Chatrapur damals Britisch-Indien nach London-Paddington zurück wo Alan Turing am <num> Juni <num> zur Welt kam
Da der Staatsdienst seines Vaters noch nicht beendet war reiste dieser im Frühjahr <num> erneut nach Indien wohin ihm seine Frau im Herbst folgte
Turing und sein älterer Bruder John wurden nach St Leonards-on-the-Sea Hastings in die Familie eines pensionierten Obersts und dessen Frau in Pflege gegeben
In der Folgezeit pendelten die Eltern zwischen England und Indien bis sich Turings Mutter <num> entschied längere Zeit in England zu bleiben und die Söhne wieder zu sich nahm
Schon in frühester Kindheit zeigte sich die hohe Begabung und Intelligenz Turings
Es wird berichtet dass er sich innerhalb von drei Wochen selbst das Lesen beibrachte und sich schon früh zu Zahlen und Rätseln hingezogen fühlte
Im Alter von sechs Jahren wurde Turing auf die private Tagesschule St Michaels in St Leonards-on-the-Sea geschickt wo die Schulleiterin frühzeitig seine Begabung bemerkte
<num> im Alter von <num> Jahren wechselte er auf die Sherborne School in Dorset
Sein erster Schultag dort fiel auf einen Generalstreik in England
Turing war jedoch so motiviert dass er die <num> Kilometer von Southampton zur Schule allein auf dem Fahrrad zurücklegte und dabei nur einmal in der Nacht an einer Gaststätte Halt machte so berichtete jedenfalls die Lokalpresse
Turings Drang zur Naturwissenschaft traf bei seinen Lehrern in Sherborne auf wenig Gegenliebe sie setzten eher auf Geistes- als auf Naturwissenschaften
Trotzdem zeigte Turing auch weiterhin bemerkenswerte Fähigkeiten in den von ihm geliebten Bereichen
So löste er für sein Alter fortgeschrittene Aufgabenstellungen ohne zuvor irgendwelche Kenntnisse der elementaren Infinitesimalrechnung erworben zu haben
Im Jahr <num> stieß Turing auf die Arbeiten Albert Einsteins
Er verstand sie nicht nur sondern entnahm einem Text selbständig Einsteins Bewegungsgesetz obwohl dieses nicht explizit erwähnt wurde
Collegezeit und theoretische Arbeiten
Turings Widerstreben für Geisteswissenschaften genauso hart wie für Naturwissenschaften zu arbeiten hatte zur Folge dass er einige Male durch die Prüfungen fiel
Weil dies seinen Notendurchschnitt verschlechterte musste er <num> auf ein College zweiter Wahl gehen das Kings College Cambridge entgegen seinem Wunsch am Trinity College zu studieren
Er studierte von <num> bis <num> unter Godfrey Harold Hardy <num>-<num> einem respektierten Mathematiker der den Sadleirian Chair in Cambridge innehatte das zu der Zeit ein Zentrum der mathematischen Forschung war
DateiTuringmaschinesvg
In seiner für diesen Zweig der Mathematik grundlegenden Arbeit On Computable Numbers with an Application to the Entscheidungsproblem <num> Mai <num> formulierte Turing die Ergebnisse Kurt Gödels von <num> neu
Er ersetzte dabei Gödels universelle arithmetisch-basierte formale Sprache durch einen einfachen gedanklichen Mechanismus eine abstrakt-formale Zeichenketten verarbeitende mathematische Maschine die heute unter dem Namen Turingmaschine bekannt ist
Entscheidungsproblem verweist auf eines der <num> wichtigsten offenen Probleme der Mathematik des <num> Jahrhunderts vorgestellt von David Hilbert <num> auf dem <num> Internationalen Mathematiker-Kongress in Paris Hilbertsche Probleme Turing bewies dass solch ein Gerät in der Lage ist jedes vorstellbare mathematische Problem zu lösen sofern dieses auch durch einen Algorithmus gelöst werden kann
Turingmaschinen sind bis zum heutigen Tag einer der Schwerpunkte der Theoretischen Informatik nämlich der Berechenbarkeitstheorie
Mit Hilfe der Turingmaschine gelang Turing der Beweis dass es keine Lösung für das Entscheidungsproblem gibt
Er zeigte dass die Mathematik in gewissem Sinne unvollständig ist weil es allgemein keine Möglichkeit gibt festzustellen ob eine beliebige syntaktisch korrekt gebildete mathematische Aussage beweisbar oder widerlegbar ist
Dazu bewies er dass das Halteproblem für Turingmaschinen nicht lösbar ist d h dass es nicht möglich ist algorithmisch zu entscheiden ob eine Turingmaschine angesetzt auf eine Eingabe initiale Bandbelegung jemals zum Stillstand kommen wird das heißt die Berechnung terminiert
Turings Beweis wurde erst nach dem von Alonzo Church <num>-<num> mit Hilfe des Lambda-Kalküls geführten Beweis veröffentlicht unabhängig davon ist Turings Arbeit beträchtlich einfacher und intuitiv zugänglich
Auch war der Begriff der Universellen Turing- Maschine neu einer Maschine welche jede beliebige andere Turing-Maschine simulieren kann
Die Eingabe für diese Maschine ist also ein verschlüsseltes Programm das von der universellen Maschine interpretiert wird und der Startwert auf den es angewendet werden soll
Alle bis heute definierten Berechenbarkeitsbegriffe haben sich bis auf die Abbildung von Worten auf Zahlen und umgekehrt als äquivalent erwiesen
<num> und <num> verbrachte Turing zumeist an der Princeton University und studierte dort unter Alonzo Church
<num> erwarb er den Doktortitel in Princeton
Seine Doktorarbeit führte den Begriff der Hypercomputation ein bei der Turingmaschinen zu sogenannten Orakel-Maschinen erweitert werden
So wurde das Studium von nicht-deterministisch lösbaren Problemen ermöglicht
Nach seiner Rückkehr nach Cambridge im Jahr <num> besuchte Turing Vorlesungen des österreichisch-britischen Philosophen Ludwig Wittgenstein <num>-<num> über die Grundlagen der Mathematik
Die beiden diskutierten und stritten vehement Turing verteidigte den mathematischen Formalismus während Wittgenstein der Meinung war dass Mathematik überbewertet sei und keine absolute Wahrheit zutage bringen könne
Kryptoanalyse
DateiBletchley Park IMG <num>JPG Während des Zweiten Weltkriegs war Turing einer der herausragenden Wissenschaftler bei den erfolgreichen Versuchen in Bletchley Park verschlüsselte deutsche Funksprüche zu entziffern
Er steuerte einige mathematische Modelle bei um sowohl die Enigma siehe auch Letchworth-Enigma als auch die Lorenz-Schlüsselmaschine siehe auch
Turingery
zu brechen
Die Einblicke die Turing bei der Kryptoanalyse der -Verschlüsselungen gewann halfen später bei der Entwicklung des ersten digitalen programmierbaren elektronischen Röhrencomputers ENIAC
Konstruiert von Max Newman und seinem Team und gebaut in der
Post Office Research Station
in Dollis Hill von einem von Tommy Flowers angeführten Team im Jahr <num> entzifferte Colossus die Lorenz-Maschine
Auch konzipierte Turing die nach ihm benannten
Bombes
Sie waren Nachfolgerinnen der von dem Polen Marian Rejewski entwickelten
Bomba
und dienten zur Ermittlung der Schlüssel von Enigma-Nachrichten
Dabei handelte es sich um ein elektromechanisches Gerät das im Prinzip mehrere Enigma-Maschinen beinhaltete und so in der Lage war viele mögliche Schlüsseleinstellungen der Enigma-Nachrichten durchzutesten und zu eliminieren bis eine mögliche Lösung gefunden war
Reductio ad absurdum
Turings Mitwirkung als einer der wichtigsten Codeknacker bei der Entzifferung der Enigma war bis in die <num>er Jahre geheim nicht einmal seine engsten Freunde wussten davon
Die Entzifferung geheimer deutscher Funksprüche war eine kriegsentscheidende Komponente für den Sieg der Alliierten im U-Boot-Krieg und im Afrikafeldzug
Arbeit an frühen Computern - Der Turing-Test
DateiPunch cards in tray for Pilot ACE computer built at the National Physical Laboratory c <num> <num>jpg Von <num> bis <num> war Turing im
National Physical Laboratory
in Teddington tätig wo er am Design der ACE
Automatic Computing Engine
arbeitete
Der Name der Maschine ist abgeleitet von der Analytical Engine des Mathematikers Charles Babbage dessen Werk Turing zeitlebens bewunderte
Ab <num> lehrte Turing an der Universität Manchester und wurde im Jahr <num> stellvertretender Direktor der Computerabteilung
Hier arbeitete er an der Software für einen der ersten echten Computer den Manchester Mark I und gleichzeitig weiterhin verschiedenen theoretischen Arbeiten
In Computing machinery and intelligence
Mind
Oktober <num> griff Turing die Problematik der künstlichen Intelligenz auf und schlug den Turing-Test als Kriterium vor ob eine Maschine dem Menschen vergleichbar denkfähig ist
Da der Denkvorgang nicht formalisierbar ist betrachtet der Test nur die Antworten einer Maschine im Dialog mit einem Menschen d h
das kommunikative Verhalten der Maschine
Wenn dieses von einem menschlichen Verhalten nicht unterscheidbar erscheint soll von maschineller Intelligenz gesprochen werden
Er beeinflusste durch die Veröffentlichung die Entwicklung der Künstlichen Intelligenz maßgeblich
<num> schrieb er das Schachprogramm Turochamp
Da es keine Computer mit ausreichender Leistung gab um es auszuführen übernahm Turing dessen Funktion und berechnete jeden Zug selbst
Dies dauerte bis zu <num> Minuten pro Zug
Das einzige schriftlich dokumentierte Spiel verlor er gegen einen Kollegen
Arbeit an mathematischen Problemen der Biologie
Von <num> bis zu seinem Tod <num> arbeitete Turing an mathematischen Problemen der theoretischen Biologie
Er veröffentlichte <num> eine Arbeit zum Thema The Chemical Basis of Morphogenesis
In diesem Artikel wurde erstmals ein Mechanismus beschrieben wie Reaktions-Diffusions-Systeme spontan Strukturen entwickeln können
Dieser als Turing-Mechanismus bekannte Prozess steht noch heute im Mittelpunkt vieler chemisch-biologischer Strukturbildungstheorien
Turings weiteres Interesse galt dem Vorkommen der Fibonacci-Zahlen in der Struktur von Pflanzen
Spätere Arbeiten blieben bis zur Veröffentlichung seiner gesammelten Werke <num> unveröffentlicht
Verfolgung wegen Homosexualität und Turings Tod
DateiBerliner CSD <num> by andreas tw - <num>jpg
<num> half der <num>-jährige Arnold Murray zu dem Turing eine gleichgeschlechtliche Beziehung hatte einem Komplizen dabei in Turings Haus einzubrechen
Turing meldete daraufhin einen Diebstahl bei der Polizei die ihm als Folge der Ermittlungen eine sexuelle Beziehung zu Murray vorwarf
Da homosexuelle Handlungen zu dieser Zeit - wie in den meisten anderen Ländern - in England strafbar waren wurde Turing wegen grober Unzucht und sexueller Perversion angeklagt
Turing sah keinen Anlass sich wegen dieser Vorwürfe zu rechtfertigen
Nach seiner Verurteilung zu einer Gefängnisstrafe wurde er vor die Wahl gestellt die Haftstrafe anzutreten oder - da zu seiner Zeit Homosexualität von weiten Teilen der Psychiatrie als Krankheit angesehen wurde - sich behandeln zu lassen
Er entschied sich für die ärztliche Behandlung zu der auch eine medikamentöse Behandlung mit dem Hormon Östrogen gehörte
Diesem wurde eine triebhemmende Wirkung zugeschrieben
Die Behandlung dauerte ein Jahr und führte zu Nebenwirkungen wie der Vergrößerung der Brustdrüse
Auch wenn er seine körperlichen Veränderungen mit Humor kommentierte muss die Verweiblichung seiner Konturen den sportlichen Läufer und Tennisspieler schwer getroffen haben
Turing erkrankte an einer Depression Im Herbst <num> begann Turing seine Therapie bei dem aus Berlin stammenden und seit <num> in Manchester lebenden Psychoanalytiker Franz Greenbaum
Dieser war ein Anhänger CG
Jungs
und war ihm von Freunden als für seinen Fall verständnisvoll empfohlen worden
Turing entwickelte auch ein freundschaftliches Verhältnis zur Familie Greenbaum die er auch privat besuchte
<num> starb Turing wahrscheinlich entsprechend der offiziellen Feststellung durch Suizid an einer Cyanidvergiftung dem Anschein nach von einem vergifteten Apfel herrührend den man halb aufgegessen neben ihm auffand
Die Ermittler versäumten es jedoch den Apfel auf Gift untersuchen zu lassen
Es wird berichtet dass Turing seit <num> nachdem er den Film Schneewittchen und die sieben Zwerge gesehen hatte immer wieder die Verse Dip the apple in the brew
Let the sleeping death seep through Tauch den Apfel tief hinein
bis das Gift wird in ihm sein in der deutschen Version des Films Apfel färbt sich strahlend rot
lockt Schneewittchen in den Tod sang
Der These dass Turings Tod ein Unfall im Zusammenhang mit einem chemischen Versuch war wird von Andrew Hodges einem seiner Biographen entschieden widersprochen Unter seinen Biographen ist die Annahme verbreitet die Auswirkungen der Hormonbehandlung seien die Hauptursache für den Suizid gewesen
Offizielle Entschuldigung Danksagung und Rehabilitierung
Ab etwa den späten <num>er Jahren unternahmen britische Bürger eine Reihe von öffentlichkeitswirksamen Aktivitäten um das von Turing erlittene Unrecht bekannt zu machen und seine formale Rehabilitierung zu erreichen also einen Widerruf oder eine Aufhebung des damaligen Urteils
Dies führte im Jahr <num> zum Erfolg
Im Jahr <num> unterzeichneten rund <num> Briten eine bei der Regierung eingereichte Online-Petition in der eine posthume Entschuldigung von der britischen Regierung gefordert wurde Der Initiator der Kampagne der britische Programmierer John Graham-Cumming regte an Alan Turing eine Ritterwürde zu verleihen
Am <num> September <num> veröffentlichte der damalige britische Premierminister Gordon Brown eine Erklärung in der er im Namen der britischen Regierung die Verfolgung Turings bedauerte und seinen außerordentlichen Beitrag während des Zweiten Weltkriegs würdigte
Dabei spielte er auch auf den strategischen Vorteil der Alliierten durch die Entschlüsselung der Enigma an und unterstrich deren Bedeutung
Da die Strafverfolgung seiner sexuellen Ausrichtung damals gesetzeskonform war wurde eine nachträgliche Aufhebung der Verurteilung Turings zunächst von offizieller Seite als unmöglich dargestellt
Noch <num> weigerte sich die Regierung von Browns Nachfolger David Cameron <num> Homosexuelle die nach dem Criminal Law Amendment Act von <num> verurteilt worden waren postum zu rehabilitieren
Im Jahr <num> wurde bekannt dass die britische Regierung die Absicht hatte Turing zu rehabilitieren
Das Oberhausmitglied John Sharkey Baron Sharkey beantragte dies
Das konservative Mitglied des Oberhauses Tariq Ahmad Baron Ahmad of Wimbledon kündigte die Zustimmung der Regierung an
Der Liberaldemokrat Sharkey hatte in den <num>er Jahren in Manchester Mathematik bei Turings einzigem Doktoranden Robin Gandy studiert
Eine dritte Lesung des Antrags beraumte die Regierung für Ende Oktober an
Am <num> Dezember <num> wurde Alan Turing durch ein allein dem Monarchen zustehendes besonderes Gnadenrecht durch ein sogenanntes Royal Pardon begnadigt
Justizminister Chris Grayling hatte diese Begnadigung bei Elisabeth II beantragt
Turing gilt damit auch als offiziell rehabilitiert
Im April <num> entschuldigte sich Robert Hannigan der damalige Leiter des britischen Geheimdienstes GCHQ für die Behandlung von Homosexuellen durch seine Institution und bezog dies ausdrücklich auf Alan Turing
Nachwirkungen der Rehabilitierung
Anfang <num> verlangten Mitglieder der Familie Alan Turings unter weiterer teils prominenter Unterstützung Stephen Fry Turing-Darsteller Benedict Cumberbatch in einer Petition an das britische Parlament die Rehabilitation auch aller anderen der in England unter den Homosexuellen-Gesetzen Verurteilten
Die Petition wurde von ca <num> Personen unterschrieben und sollte von Turings Großneffen Nevil Hunt und der Großnichte Rachel Barns überreicht werden
Am <num> Oktober <num> lehnte das britische Parlament einen Gesetzesentwurf ab der eine Rehabilitation in Form einer generellen Rehabilitation aller lebenden früher für Homosexualität verurteilten Personen vorsah
Dieser Gesetzesentwurf ging einigen zu weit anderen nicht weit genug Am <num> Januar <num> wurde von Königin Elisabeth II
ein Gesetz in Kraft gesetzt das aufbauend auf der Begnadigung von Turing allen Männern die Strafe aufhebt falls zu dem Zeitpunkt beide über <num> Jahre alt waren als sie den geahndeten Akt in gegenseitigem Einvernehmen vollzogen
Ausgenommen sind weiterhin Verurteilungen wegen homosexueller Handlungen in öffentlichen Toiletten
Das Gesetz schließt auch bereits verstorbene Personen ein
Ein noch lebender Betroffener kann beantragen dass die Strafe aus seiner polizeilichen Führungsakte gestrichen wird und Historiker können darauf hinweisen dass eine Verurteilung verstorbener Personen nach geltendem Recht ungültig ist
Das Gesetz das von Justizminister Sam Gyimah als Turings Gesetz bezeichnet wurde ist eine Ergänzung zum
Policing and Crime Act
und nimmt keinen Bezug auf andere Gesetze unter denen homosexuelle Handlungen verfolgt werden konnten
Von Michael Cashman einem der Initiatoren des Gesetzes wurden jedoch weitere Vereinbarungen abgesichert die einen entsprechend umfassenden Straferlass für alle homosexuellen Handlungen ermöglichen
Postume Ehrungen
DateiTuring statue Surreyjpg Am <num> März <num> wurde der Asteroid <num> Turing nach ihm benannt
Eine Turing-Statue wurde am <num> Juni <num> in Manchester enthüllt
Sie steht im Sackville Park zwischen den wissenschaftlichen Gebäuden der Universität Manchester und dem bei Homosexuellen beliebten Viertel der Canal Street
An seinem <num> Todestag dem <num> Juni <num> wurde zum Gedenken an Turings frühzeitigen Tod eine Tafel an seinem früheren Haus Hollymeade in Wilmslow enthüllt
Der Turing Award wird jährlich von der
Association for Computing Machinery
an Personen verliehen die bedeutende Beiträge zur Informatik geleistet haben
Er wird weithin als Nobelpreis der Informatik angesehen
Der Bletchley Park Trust hat am <num> Juni <num> eine Statue Turings in Bletchley Park enthüllt
Die Skulptur wurde von Stephen Kettle gestaltet der als Material für sein Kunstwerk walisischen Schiefer verwendete
Im Turing-Jahr <num> fanden zu Alan Turings hundertstem Geburtstag weltweit Veranstaltungen zur Würdigung seiner Leistungen und zum Gedenken daran statt
Im Jahr <num> wurde er in die
Hall of Honor
Ehrenhalle des US-Geheimdienstes NSA National Security Agency aufgenommen
Verschiedenes
DateiTuring Plaquejpg
Alan Turing war ein hervorragender Langstreckenläufer
Von <num> an startete er bei Wettkämpfen für den Walton Athletic Club Bei den englischen Meisterschaften im Marathon <num> wurde er Fünfter in <num><num> h nur gut fünf Minuten langsamer als die Zeit mit der sich Stan Jones beim Polytechnic Marathon des folgenden Jahres bei dem Turing verletzt fehlte als dritter britischer Mann hinter Jack Holden und Tom Richards für den Marathon der Olympischen Spiele <num> in London qualifizierte
<num> musste Turing wegen einer Beinverletzung seine Sportkarriere beenden
Angeblich hat sich Apple beim Design seines Logos eines angebissenen Apfels ursprünglich in Regenbogenfarben vom Tod des Computerpioniers Turing inspirieren lassen
Diese Annahme wurde jedoch von Steve Jobs mit den Worten widerlegt dass er wünschte damals daran gedacht zu haben er es aber nicht habe Apple hatte die Legende im Sinn nach der Isaac Newton zu seiner Gravitationstheorie inspiriert worden sein soll als ihm ein Apfel auf den Kopf fiel Der Logo-Designer Rob Janoff meinte der Biss sei lediglich als Größenmaßstab hinzugefügt worden um etwa eine Verwechslung mit einer Kirsche auszuschließen
In seinen Lebenserinnerungen berichtet der Computerpionier Heinz Billing vom Max-Planck-Institut für Physik München dass sich Alan Turing und Konrad Zuse <num> in Göttingen getroffen haben
In Form eines Kolloquiums befragten britische Fachleute neben Turing u a John R Womersley und Arthur Porter deutsche Wissenschaftler wie Zuse Billing Alwin Walther und Helmut Schreyer
<num> wurde im Heinz Nixdorf MuseumsForum in Paderborn zu Ehren von Turing ein einjähriger Zyklus von Ausstellungen unter dem Titel Genial
Geheim gezeigt
Berichte von Bekannten über ihn sind teilweise skurril Er habe seine Teetasse immer mit einem Fahrradschloss an seine Heizung gekettet und sei mit zweckentfremdeter Gasmaske Fahrrad gefahren um sich gegen seinen Heuschnupfen beim Fahrradfahren zu schützen
Bewohner des Örtchens Bletchley erschraken darüber und glaubten bei seinem Anblick an einen deutschen Giftgasangriff
Am Institut für Informatik der Westfälischen Wilhelms-Universität in Münster wurden Ende der <num>er Jahre von Achim Clausing zwei Originaldrucke der bedeutendsten Veröffentlichungen Turings im Nachlass von Heinrich Scholz entdeckt wovon eine seit <num> verschollen gewesen war Es handelt sich um die Arbeit On Computable Numbers with an Application to the Entscheidungsproblem von <num> die Scholz noch im selben Jahr mit einer Postkarte von Turing angefordert hatte Auf Basis dieser Arbeit hielt Scholz nach Clausings Aussage das weltweit erste Seminar über Informatik Die zweite Arbeit stammt aus dem Jahr <num> und ist eine Abhandlung über die Entwicklung der künstlichen Intelligenz die Turing mit einem handschriftlichen Kommentar versah Dies ist wohl mein letztes Exemplar
Bei Sothebys wurden vergleichbare Drucke Turings die keine Widmung aufwiesen für <num> Euro versteigert
<num> wurde eine bis dahin unbekannte Sammlung von <num> Briefen von Turing entdeckt
Eine weitere Sammlung mit <num> Briefen wurde darüber hinaus im gleichen Jahr in einem Aktenschrank in einem Lagerraum der Universität Manchester aufgefunden
Die Briefe stammen aus den Jahren <num> bis <num>
Die an der Universität Manchester entdeckten Briefe behandeln überwiegend seine Forschungsarbeit und wurden vom Archiv der Universität übernommen sie sind im Internet einsehbar
Im Juli <num> gab die Bank of England bekannt dass auf der ab Ende <num> in Umlauf kommenden neuen <num>-Pfund-Note das Bild von Turing und sein Zitat This is only a foretaste of what is to come and only the shadow of what is going to be zu sehen sein wird
Werke
Veröffentlichungen
Wichtige Veröffentlichungen
Englische Ausgaben
Deutsche Ausgabe und Übersetzungen
Patente
<num>
<num>
Literatur Auswahl
Theorie und Diskussion
David J Bolter Turings Man Western Culture in the Computer Age
University of South Carolina Press Chapel Hill <num> ISBN <num>-<num>-<num>-<num>
S Barry Cooper Jan van Leeuwen Hrsg Alan Turing His Work and Impact Elsevier New York NY <num> ISBN <num>-<num>-<num>-<num>-<num>
Jack Copeland Jonathan Bowen Mark Sprevak u Robin Wilson Hrsg The Turing Guide
Oxford University Press Oxford <num> ISBN <num>-<num>-<num>-<num>-<num>
Juliet Floyd Alisa Bokulich Hrsg Philosophical Explorations of the Legacy of Alan Turing
Turing <num>
Springer Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
Boston Studies in the History of Science <num>
Geschichte und Biographie
George Dyson Turings Cathedral
The Origins of the Digital Universe
Pantheon <num> ISBN <num>-<num>-<num>-<num>-<num> Turings Kathedrale Die Ursprünge des digitalen Zeitalters Propyläen Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
Francis Harry Hinsley Alan Stripp Codebreakers - The inside story of Bletchley Park Oxford University Press Reading <num> ISBN <num>-<num>-<num>-<num>
Andrew Hodges Alan Turing - The Enigma Burnett Books London und Simon and Schuster New York <num> Vintage New York <num> Biografie Alan Turing - Enigma
Kammerer und Unverzagt Berlin <num> <num> Auflage Springer <num> ISBN <num>-<num>-<num>-<num>
David Leavitt The Man Who Knew Too Much
Alan Turing and the Invention of the Computer
W W Norton
Co <num> ISBN <num>-<num>-<num>-<num>
Dermot Turing Alan Turing - The Life of a Genius The History Press <num> ISBN <num>-<num> Prof - Alan Turing Decoded Pavilion Books <num> ISBN <num>-<num>
Gordon Welchman The Hut Six Story - Breaking the Enigma Codes Allen Lane London <num> Cleobury Mortimer MM Baldwin Shropshire <num> ISBN <num>-<num>-<num>-<num>
Belletristik
Rolf Hochhuth Alan Turing
Erzählung
Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num>
David Lagercrantz Der Sündenfall von Wilmslow
Übersetzung aus dem Schwedischen Wolfgang Butt
Piper München <num> zuerst <num>
Wolf Schneider Große Verlierer
Von Goliath bis Gorbatschow
Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num> darin enthalten ein Kapitel über Alan Turing
Neal Stephenson
Cryptonomicon
Goldmann <num> ISBN <num>-<num>-<num>-<num> Originalausgabe New York <num>
Robert Harris
Enigma
Heyne München <num> ISBN <num>-<num>-<num>-<num>-<num> Englische Originalausgabe <num>
Filme Auswahl
<num> Breaking the Code Der codierte Mann
Fernsehfilm-Biographie Großbritannien <num> Min Buch Hugh Whitemore Regie Herbert Wise Produktion BBC mit Derek Jacobi als Turing online-Video
<num>
Enigma - Das Geheimnis Regie Michael Apted
Dieser Film basiert auf dem Roman
Enigma
des britischen Autors Robert Harris aus dem Jahre <num>
<num> Codebreaker
Doku-Drama Großbritannien Buch Craig Warner Regie Clare Beavan Nic Stacey Produktion Channel <num> mit Ed Stoppard als Alan Turing Deutschsprachige Erstsendung bei ServusTV als Der Codeknacker
Alan Turing
Erstsendung <num> Juni <num> - Inhaltsangabe
<num> Der Fall Alan Turing oder Wie ein Mathegenie Hitler knackte OT La drôle de guerre dAlan Turing ou Comment les maths ont vaincu Hitler Dokumentarfilm Frankreich <num> <num> Min Buch und Regie Denis van Waerebeke Produktion Les Films dici arte France Off World RTBF Erstsendung <num> Juni <num> bei arte Inhaltsangabe von arte online-Video
<num>
The Imitation Game Doku-Drama Großbritannien <num> <num> Min Buch Graham Moore Regie Morten Tyldum Produktion Weinstein
Mit Benedict Cumberbatch als Alan Turing Keira Knightley als Joan Clarke Charles Dance u a nach der Biographie von Andrew Hodges
Musik
A Man From The Future Pet Shop Boys <num> Die Texte im Stück basieren auf der Biographie Alan Turing The Enigma von Andrew Hodges der hier mit Tennant und Lowe zusammenarbeitete
Weblinks
Alan Turing in der Ehrenrolle Roll of Honour von Bletchley Park
Andrew Hodges Alan-Turing-Portal - turingorguk englisch
The Turing Archive for the History of Computing - alanturingnet englisch
The Turing Digital Archive In University of Cambridge englisch
Genial
geheim - Alan Turing in <num> Etappen In Heinz Nixdorf MuseumsForum Sonderausstellung zum <num>
Geburtstag von Alan Turing <num>
Artikel
André Schulz
Turing und Schach
In Schach Nachrichten <num> Juni <num>
Stefan Betschon
Turingmaschine im Rückwärtsgang
In
Neue Zürcher Zeitung
<num> Januar <num> zum <num>
Geburtstag von Alan Turing
Einzelnachweise
Alan Turing Colleagues share their memories
In
BBC News
<num> Juni <num> alphabetische Mitgliederliste der Royal Society PDF <num> MB abgerufen am <num> Juli <num>Andrew Hodges
Alan Turing - a short biography
In turingorg <num> Alan Turing Manchester celebrates pardoned genius
In
BBC News
<num> Dezember <num> abgerufen am <num> Dezember <num>Caroline Davies
Enigma Codebreaker Alan Turing receives Royal Pardon
In
The Guardian
<num> Dezember <num>Friedhelm Greis
Homosexualität Queen begnadigt Alan Turing
In
golemde
<num> Dezember <num> Royal pardon for codebreaker Alan Turing
In BBC News <num> Dezember <num> abgerufen am <num> Dezember <num>siehe auch Liste
Recipients of British royal pardons
sowie Artikel
Royal prerogative of mercy
in der englischsprachigen Wikipedia Er knackte den geheimen Code Er wollte nichts als seine Ruhe Doch man liess sie ihm nicht Am Ende wurde er von den Briten diszipliniert deren Überleben er gesichert hatte Eine Hommage an Alan Turing den Dechiffreur der Nazi-Enigma und Erfinder des Computers In
Das Magazin
Nr <num> <num> Themenheft Digitales GlückAndré Schulz
Die goldene Gans die niemals schnattert
In Schach Nachrichten <num> Juni <num> über Turing und SchachBoris Mayer
Kein Code war ihm zu schwer
In
Jungle World
<num> Juni <num> Nr <num> abgerufen am <num> August <num>
In BBC News <num> Juni <num> abgerufen am <num> Juni <num> to seep through sth
In reversonet Collins Wörterbuch online siehe unten unter den Beispielen aufgerufen <num> Februar <num> NA Thousands call for Turing apology
In BBC News <num> August <num>Felix Knoke
Netzweltticker Briten fordern Entschuldigung an Computer-Pionier Turing
In
SpOn
<num> September <num>Werner Pluta
Alan Turing Späte Rehabilitierung für den Computerpionier
In
golemde
<num> Juli <num> abgerufen am <num> Juli <num>Nicholas Watt
Enigma codebreaker Alan Turing to be given posthumous pardon
In The Guardian <num> Juli <num> abgerufen am <num> Juli <num> Royal pardon for codebreaker Alan Turing
In
BBC News
<num> Dezember <num> abgerufen am <num> März <num> Katholische Nachrichten-Agentur KNA
dpa
Schwule sollen rehabilitiert werden
In
Badische Zeitung
<num> Februar <num>Owen Bowcott
UK issues posthumous pardons for thousands of gay men
In The Guardian <num> Januar <num> abgerufen am <num> Februar <num> Fotos Die Turing-Statue in Bletchley Park In whudatde <num> August <num> Turing-Jahr <num>
In
Gesellschaft für Informatik
<num> abgerufen am <num> August <num>Chris Christensen
Review of IEEE Milestone Award to the Polish Cipher Bureau for The First Breaking of Enigma Code
In
Cryptologia
<num> April <num> S <num> doi<num><num><num> bezahlpflichtigI E G Green
In isolation and autonomy the marathon ambition of a computer genius Alan Turing
In Track Stats September <num> englischPat Butcher
In Praise of Great Men
In globerunnerorg <num> September <num> englischJohn Graham-Cumming
An Olympic honour for Alan Turing
In The Guardian <num> März <num> englisch He Steve Jobs replied that he wished he had thought of that but hadnt In Walter Isaacson
Steve Jobs <num>Holden Frith
Unraveling the tale behind the Apple logo
In
CNN
<num> Oktober <num> englisch Heinz Billing Ein Leben zwischen Forschung und Praxis Selbstverlag F Genscher Düsseldorf <num> S <num> wiedergegeben nach Herbert Bruderer Konrad Zuse und die Schweiz Wer hat den Computer erfunden Oldenbourg Wissenschaftsverlag München <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> online Hans-Heinrich Pardey Genial und schrullig In
Frankfurter Allgemeine Sonntagszeitung
<num> Januar <num> ArtikelanfangLaura Döing
Die geheimen Taten des Alan Turing
In
Deutsche Welle
<num> Januar <num>Elmar Ries
Auf den Spuren eines Pioniers In der Unibibliothek Münster liegen Sonderdrucke des Informatikers Alan Turing
In Westfälische Nachrichten <num> Januar <num> abgerufen am <num> Dezember <num> Josh Halliday
In The Guardian <num> August <num> abgerufen am <num> August <num> Alan Turing Papers Additional im Archiv der Universität ManchesterConcert
A Man From The Future
In
Pet Shop Boys
<num> April <num>Teresa Dapp
Musikalische Verneigung vor Alan Turing
In
dpa
Mittelbayerische Zeitung
<num> Juli <num>
DateiTommarp kloster <num>JPG DateiScale drawing underwaterjpg DateiArrow and spear heads - from-DC<num>jpg Datei<num> <num> Kampagne Sommer Bild <num> Keramikofenjpg Die Archäologie
und λόγος
lógos
Lehre wörtlich also Lehre von den Altertümern ist eine Wissenschaft die mit naturwissenschaftlichen und geisteswissenschaftlichen Methoden die kulturelle Entwicklung der Menschheit erforscht
Sie hat sich weltweit zu einem Verbund unterschiedlichster theoretischer und praktischer Fachrichtungen entwickelt
Die Archäologie interessiert sich ausschließlich für den Menschen und seine materiellen Hinterlassenschaften wie etwa Gebäude Werkzeuge und Kunstwerke
Sie umfasst einen Zeitraum von den ersten Steinwerkzeugen vor etwa <num> Millionen Jahren bis in die nähere Gegenwart
Aufgrund neuer Funde in Afrika die etwa <num> Millionen Jahre alt sind wird auch ein deutlich früherer Beginn der Werkzeugherstellung in Betracht gezogen Materielle Hinterlassenschaften der jüngsten Geschichte beispielsweise Konzentrationslager und Bunkerlinien aus dem Zweiten Weltkrieg werden heute ebenfalls mit archäologischen Methoden ausgewertet auch wenn dieser Ansatz einer zeitgeschichtlichen Archäologie fachintern umstritten ist
Obwohl die Archäologie eine verhältnismäßig junge Wissenschaft ist ist es kaum mehr möglich alle Zeiträume zu überblicken so dass sich verschiedene Fachrichtungen herausbildeten
Dabei können die Epochen regional unterschiedlich datiert sein teilweise sind sie nicht überall dokumentierbar Neben der Orientierung an Epochen z B
Mittelalterarchäologie oder Regionen z B
Vorderasiatische Archäologie gibt es auch die Spezialisierung auf bestimmte Themengebiete z B
Christliche Archäologie Rechtsarchäologie Industriearchäologie
Obwohl die Methodik sich großteils ähnelt können die Quellen unterschiedlich sein
In der Vor- und Frühgeschichte hat man es hauptsächlich mit materieller Kultur zu tun in der Frühgeschichte kann dabei teils auf Schriftquellen zurückgegriffen werden
Diese stehen für Archäologen im Gegensatz zu Wissenschaftlern anderer Teildisziplinen der Geschichtswissenschaft aber nicht im Mittelpunkt
Erkenntnisse zu Umwelt Klima Ernährung oder zum Alter von Funden tragen zur Rekonstruktion vergangener Kulturen bei
Forschungsgeschichte
Anfänge der Altertumsforschung in Europa
In Europa entwickelte sich die Archäologie um <num> weil man Zeugnisse für die in den Quellen der Antike geschilderten Ereignisse finden wollte Cyriacus von Ancona
um <num>
um <num> ein italienischer Kaufmann und Humanist gilt als einer der Gründungsväter der modernen klassischen Archäologie
Die in der Renaissance einsetzende Wiedergeburt klassisch-antiker Gelehrsamkeit führt im <num> und <num> Jahrhundert zu einem gesteigerten Interesse an griechischen und römischen Altertümern und zu einer Welle der Sammelleidenschaft antiker Kunstgegenstände
Doch auch weniger reisefreudige Gelehrte beginnen sich für die vorhandenen Zeugnisse vergangener Zeiten zu interessieren
Ab Mitte des <num> Jahrhunderts tritt an die Stelle der Sammelleidenschaft die akribische Erfassung der Denkmäler
In dieser Zeit werden zahlreiche Enzyklopädien und Kataloge veröffentlicht welche im späten <num> Jahrhundert vielfach mit Kupferstichen und Holzschnitten illustriert werden
In England veröffentlicht William Camden <num>-<num> im Jahre <num> seine Britannia einen Katalog der sichtbaren Altertümer
Bemerkenswert ist dass er bereits Bewuchsmerkmale in Kornfeldern bemerkt und als solche interpretiert
Michele Mercati <num>-<num> gilt als der erste europäische Gelehrte der Steinwerkzeuge als solche einstufte sein Werk wird jedoch erst <num> veröffentlicht
Trotz großer Popularität hat die Archäologie als Wissenschaft noch keinen Stellenwert denn es herrscht die Ansicht vor dass ausschließlich historische Quellen und die Bibel zur Interpretation der Vergangenheit geeignet seien
So gilt es noch lange als ein Faktum dass - wie James Ussher aus der Bibel ableitete - die Menschheit im Oktober <num> v Chr entstand
<num> wagt es Isaac de La Peyrère die sogenannten Donnerkeile Steinzeitartefakte menschlichen Aktivitäten zuzuordnen welche vor Adam lebten Präadamiten-Hypothese Nach einer Intervention der Inquisition widerruft er seine Theorie
DateiSepulture de CocherelJPG DateiJättakullen den <num> juli <num> bild <num>JPG In Skandinavien werden Bodendenkmäler schon früh beachtet
Bereits <num> gräbt man einen Dolmen bei Roskilde aus
Im Jahre <num> erhält Uppsala einen Lehrstuhl für Altertumskunde
<num> wird in Houlbec-Cocherel in Nordfrankreich eine neolithische Grabkammer ausgegraben
Sie gilt als die älteste archäologische Grabung weil hier <num> der erste erhaltene Grabungsbericht erstellt wurde
Der Kieler Professor Johann Daniel Major führt um <num> umfangreiche Ausgrabungen in Jütland durch und lässt zahlreiche Hügelgräber öffnen
Sein Ziel ist es die Herkunft der Einwohner der Halbinsel mit archäologischen Methoden zu klären
Bernard de Montfaucons LAntiquité expliquée erscheint ab <num>
In zehn Bänden stellt er Kunstgegenstände aus dem Mittelmeerraum dar
Montfaucons Werk bleibt für lange Zeit das Standardwerk
Mitte des <num> bis Mitte des <num> Jahrhunderts
Archäologische Forschungsmethoden setzten sich nun sukzessiv durch
Oftmals trafen einzelne Gelehrte schon früh bahnbrechende Schlussfolgerungen welche aber oft - da noch nicht zeitgemäß - unbeachtet blieben
Einer der Bahnbrecher war der französische Amateurarchäologe Jacques Boucher de Perthes der als Erster prähistorische Artefakte richtig zuordnete wofür ihm aber erst mehr als <num> Jahre später durch die Bestätigung Charles Lyells <num>-<num> Anerkennung zuteilwurde
Eine wichtige Erkenntnis war die Entdeckung des stratigraphischen Prinzips
Bereits lange vorher war die Zusammengehörigkeit und somit Gleichaltrigkeit von Funden welche sich in einer Schicht befanden beispielsweise ein Steinartefakt im Fundzusammenhang mit einer ausgestorbenen Tierart immer wieder diskutiert worden wurde aber nicht allgemein akzeptiert
Ein Modell das in seinen Grundzügen noch heute gilt wurde von <num> von Christian Jürgensen Thomsen veröffentlicht
Er war Kurator in Kopenhagen und erfand das Dreiperiodensystem das die Vorgeschichte der Menschheit in drei Phasen einteilt nämlich die Steinzeit die Bronzezeit und die Eisenzeit
Etwa <num> Jahre später um <num> unterschied J Lubbock die Steinzeit noch in die des geschlagenen und die des geschliffenen Steins
Die Begriffe Paläolithikum Altsteinzeit und Neolithikum NeusteinzeitJungsteinzeit waren geboren
Die Epochen sind in sich vielfach untergliedert aber die damals gefundene Unterteilung gilt - mit Einschränkungen - bis heute
DateiPompeji um <num> ueberblickjpg
Die ersten großen Ausgrabungen fanden in den antiken Städten Pompeji und Herculaneum statt
Beide waren am <num> August <num> n Chr durch den Ausbruch des Vesuvs ausgelöscht worden
Pompeji wurde Ende des <num> Jahrhunderts beim Bau einer Wasserleitung wiederentdeckt
<num> begannen die Grabungen
In Herculaneum wurde erstmals <num> gegraben <num> ließ Karl III
von Neapel die Stadt gezielt ausgraben
<num> konnte das Theater die Basilika und die Villa dei Papiri freigelegt werden
Mit seinem Sendschreiben von den Herculanischen Entdeckungen der ersten archäologischen Publikation begründete Johann Joachim Winckelmann <num> die neue Wissenschaft der Archäologie und gilt seither als Vater der klassischen Archäologie
Winckelmann ist auch der Erste der eine Periodisierung und geschichtliche Einordnung der griechischen Kunst versucht
Seine Entwicklungsstufen alter Stil - hoher Stil - schöner Stil - Stil der Nachahmer - Verfall der Kunst sind durch die enthaltene Wertung jedoch überholt
Für die Verbreitung seiner Forschung und deren Rezeption in der zeitgenössischen Literatur und Kunst war der Göttinger Professor Christian Gottlob Heyne entscheidend der mit Winckelmann korrespondierte seine Schriften rezensierte und bekanntmachte und in seinen Vorlesungen verwendete
<num> wurde an der Christian-Albrechts-Universität zu Kiel der erste Lehrstuhl für klassische Archäologie eingerichtet
Die ägyptischen Baudenkmäler allen voran die Pyramiden waren bereits im Altertum beliebte Reiseziele siehe Weltwunder
Im <num> Jahrhundert hatte sich die Erkenntnis durchgesetzt dass es sich hierbei um Königsgräber handelt
Die Ägyptologie nahm mit Napoléon Bonapartes Ägypten-Feldzug <num> ihren Anfang
In Begleitung des Heeres befanden sich auch Wissenschaftler
Von besonderer Bedeutung ist der Fund des Steins von Rosetta welcher <num> Jean-François Champollion die Entzifferung der Hieroglyphen ermöglichte
Von besonderer Bedeutung für die ägyptische Archäologie ist Auguste Mariette <num>-<num> welcher ab <num> als Direktor des ägyptischen Altertümerdienstes mehr als dreißig Fundstätten ausgrub
Seine Methoden waren brachial beispielsweise Sprengladungen
Die Feststellung der Fundumstände und wissenschaftliche Auswertungen waren damals noch nicht festgelegt aber er beendete die Ära der reinen Schatzsucher so Giovanni Battista Belzoni <num>-<num> welche zuvor zahllose Funde nach Europa geschafft hatten
Mariette selbst hat seit <num> rund <num> Objekte nach Paris Louvre gebracht
Nun setzte er sich jedoch vehement dafür ein dass Ägyptens Altertümer nicht mehr außer Landes verschleppt wurden
Zur Aufbewahrung der Funde gründete Mariette den Vorläufer des Ägyptischen Nationalmuseums in Kairo
Karl Richard Lepsius <num>-<num> erstellte zwischen <num> und <num> eine umfassende Aufnahme ägyptischer und nubischer Denkmäler
<num> wurde das Ergebnis in den zwölf Bänden der Denkmaeler aus Aegypten und Aethiopien veröffentlicht welche allein <num> Farbtafeln enthalten
Um die archäologische Erforschung Griechenlands machte sich um <num> besonders Ludwig Ross verdient der als erster systematische Ausgrabungen auf der Akropolis von Athen durchführte
Ab Mitte des <num> Jahrhunderts
Mitte des <num> Jahrhunderts entwickelt sich die Archäologie zunehmend zur Wissenschaft
Unterscheiden sich die Ausgräber bisher nur unwesentlich von Schatzsuchern und Grabräubern werden nun die Grabungstechniken verfeinert eine gute Dokumentation und exakte Einordnung der Funde immer wichtiger
Antoine Ives Goguet <num>-<num> hat bereits <num> die Auffassung vertreten es müsse drei Stufen prähistorischer Technologie Steinzeit Bronzezeit Eisenzeit gegeben haben
Durchsetzen konnte sich das Dreiperiodensystem jedoch erst mit dem Dänen Christian Jürgensen Thomsen <num>-<num> welcher erstmals ein Museum <num> nach diesem Prinzip ordnet
Sir John Lubbock <num>-<num> führt <num> eine weitere Unterteilung der Steinzeit in Paläolithikum Altsteinzeit und Neolithikum Jungsteinzeit ein
Erst ab <num> wird das hohe Alter der Menschheit allgemein anerkannt
Im selben Jahr erscheint Darwins
Über die Entstehung der Arten
Der bereits <num> entdeckte Fund des Neandertalers welcher von Johann Carl Fuhlrott und Hermann Schaaffhausen vergeblich als eiszeitlich eingestuft wurde kann sich als solcher in Deutschland erst ab <num> durchsetzen als Rudolf Virchow stirbt der als pathologische Autorität jede weiterführende Diskussion unterbunden hatte
In Schweden entwickelt Oscar Montelius <num>-<num> ein System der differenzierten Typologie zur Einordnung Periodisierung von Fundstücken und schafft die Grundlage einer relativen Chronologie
<num><num> werden aufgrund eines ungewöhnlich niedrigen Wasserstandes bei Obermeilen am Zürichsee hölzerne Pfeiler Steinbeile und Keramik entdeckt
Die Siedlung wird von Ferdinand Keller untersucht
Lange Zeit glaubt man bei diesen Feuchtbodensiedlungen habe es sich um Pfahlbauten im Wasser gehandelt
Ab den <num>er Jahren entspann sich eine heftige Diskussion um die Lage der Pfahlbauten
Es konkurrierten Ufer- und Wasserpfahlbauten
Heute weiß man dass es Land- und Wasserpfahlbauten gab
Die neuen Untersuchungen in Hornstaad am Bodensee belegen Pfahlbauten im Wasser bis zu <num> Meter vom Seeboden abgehoben
Rekonstruktionen beispielsweise in Unteruhldingen am Bodensee zeigen nicht nur die verschiedenen Lösungsvorschläge der Archäologie sondern auch den aktuellen Forschungsstand nach den Befunden der Unterwasserarchäologie Pfahlbaumuseum Unteruhldingen
<num> beginnen die Ausgrabungen in Hallstatt
Die archäologische Erforschung der Kelten beginnt <num> als Oberst Schwab die ersten Ausgrabungen in La Tène am Neuenburgersee Schweiz durchführt
<num> wird die Eisenzeit Europas erstmals in eine ältere Phase Hallstattzeit und einer jüngeren Latènezeit unterteilt
Édouard Lartet <num>-<num> untersucht <num> eine Fundstätte in den Pyrenäen Massat und findet dabei auch eine Geweihspitze mit eingraviertem Bärenkopf der erste Fund jungpaläolithischer Kunst
Später gräbt er mehrere französische Höhlenfundplätze Gorge dEnfer Laugerie Haute La Madeleine und Le Moustier aus
Besondere Aufmerksamkeit erlangen die großartigen Höhlenmalereien welche <num> in der Höhle von Altamira entdeckt werden
Die Entwicklung der Klassischen Archäologie in der zweiten Hälfte des <num> Jahrhunderts wird von Heinrich Schliemann <num>-<num> dominiert
Der Geschäftsmann und Hobbyarchäologe Schliemann gilt als Begründer der Vorgeschichtsarchäologie Griechenlands und des ägäischen Raumes
<num> gräbt er auf Ithaka und <num> beginnt er in Hissarlik zu graben
Dort vermutet er das Troja Homers und wird recht behalten obwohl er sich in der Bauperiode selbst täuschte
Seine Ausgrabungsmethoden waren sehr umstritten so mancher Fachmann hält von Schliemanns Fähigkeiten nichts
Sein Ruhm stützt sich vor allem auf die wertvollen Funde beispielsweise Schatz des Priamos Seine Entdeckung prähistorischer vorhomerischer Kulturen und Siedlungen löst zahlreiche weitere Grabungen im ägäischen Raum aus
Lange unterschätzt wurden die durch ihn bewirkten methodischen Fortschritte wie die Betonung der Stratigraphie oder der Einsatz der Fotografie als Mittel der archäologischen Dokumentation
<num> erhielt der Gründer des Instituts für Ur- und Frühgeschichte an der Universität Wien Moritz Hoernes die erste das Gesamtgebiet der Prähistorischen Archäologie umfassende Lehrbefugnis Europas
<num> und <num> Jahrhundert
DateiHoward carterjpg DateiBarzanjpg In Ägypten leistet ab <num> Sir William Matthew Flinders Petrie <num>-<num> als Forscher und Ausgräber Pionierarbeit
Ein Meilenstein der archäologischen Forschung sind seine Methoden und Ziele der Archäologie die er <num> veröffentlicht
Darin legt Flinders Petrie vier Prinzipien dar
Sorgfalt im Umgang mit den Monumenten die man ausgräbt und Rücksichtnahme auf potenzielle künftige Ausgräber
peinliche Sorgfalt bei der Ausgrabung und Registrierung jedes vorgefundenen Details
detaillierte und saubere Vermessung und Kartierung
komplette Veröffentlichung der Resultate
<num> erscheint der erste Band des Handbuchs der Archäologie Herausgeber ist Heinrich Bulle <num>-<num>
Als vorbildliche Grabung dieser Zeit gilt die <num> begonnene Ausgrabung des Gräberfeldes von Assini Argolis welche von schwedischen Archäologen vorgenommen wird
Der gesamte Aushub wird gesiebt und eine erstklassige Grabungsdokumentation erstellt
Der berühmteste archäologische Fund des <num> Jahrhunderts gelingt Howard Carter <num>-<num> im selben Jahr
Er findet nach sechsjähriger Suche das Grab des Tut-anch-Amun
Pionier der Luftbildarchäologie war nach dem Ersten Weltkrieg der britische Pilot Osbert G S Crawford er fotografiert vom Flugzeug aus archäologische Fundstätten in England
Gustaf Kossinna <num>-<num> stellt <num> seine siedlungsarchäologischen Methoden vor
Seine Interpretationen welche den Germanen eine überragende kulturelle Bedeutung zuschreiben dienen dem Nationalsozialismus als Beweis für die Überlegenheit der Germanen und der arischen Rasse
Die Diskreditierung in der Nachkriegszeit führte dazu dass auf Jahrzehnte eine Anbindung archäologischer Funde an ethnische Gruppen obsolet war
Die erste ordentliche Professur wurde <num> in Marburg geschaffen und im folgenden Jahr mit Gero Merhart von Bernegg aus Bregenz besetzt
Er hatte sich <num> mit Die Bronzezeit am Jenissei habilitiert
Bei ihm promovierten bis zu seiner Zwangspensionierung durch die Nationalsozialisten im Jahr <num> <num> Studenten nach dem Krieg kamen fünf weitere hinzu
Ab <num> dominierte in Deutschland die Marburger Schule die diese Akademiker bildeten
Gero von Merhart wie er meist genannt wird legte das Fach auf strenge Erfassung Systematisierung und Katalogisierung fest und mied weitgehend die kulturgeschichtliche Deutung
Thor Heyerdahl fuhr <num> mit einem Floß von Südamerika nach Polynesien und kann als einer der Begründer der Experimentellen Archäologie betrachtet werden
Im <num> Jahrhundert greift die Archäologie vermehrt auf Techniken anderer Wissenschaften zurück
Als Beispiele seien die <num> entwickelte C-Datierung zur Datierung von organischen Stoffen und die Strontiumisotopenanalyse zur Erforschung der Wanderbewegungen der ur- und frühzeitlichen Menschen genannt
Die Archäologie hat sich zur Verbundwissenschaft entwickelt
Die Erforschung der <num> in den Ötztaler Alpen gefundenen vorgeschichtlichen Leiche Similaun-MannÖtzi ist hierfür beispielhaft
Mit Hilfe der DNA-Analyse konnten weltweit erstmals die Verwandtschaftsbeziehungen von <num> Individuen aus einer bronzezeitlichen Begräbnisstätte in der Lichtensteinhöhle rekonstruiert werden
Die New Archaeology der <num>er Jahre brachte die Forderung Erkenntnisse aus Lebenswissenschaften in die Archäologie einzuführen
Das Konzept der Tragfähigkeit stammt aus der Ökologie und wurde angewandt um Fragen von Bevölkerungsdichte und Siedlungsentwicklung zu untersuchen
Optimal Foraging konnte Reaktionen auf Klimaveränderungen gleichermaßen erklären wie jahreszeitliche Wanderungen und Landnutzungsformen
Zudem wurden mathematische Simulationen und Modellbildungen und computergestützte Geoinformationssysteme als Methoden in die Archäologie eingebracht
Die New Archaeology war besonders im angelsächsischen Kulturraum stark entwickelt und konnte sich im deutschen Sprachraum nie durchsetzen
Als Grund gilt dass in der angelsächsischen Tradition die Archäologie traditionell zur Anthropologie gehört nicht zu den Geschichts- oder Kulturwissenschaften
Als Antwort auf die New Archaeology entstand in den <num>er Jahren die Postprozessuale Archäologie die Methoden aus den Kultur- und Sozialwissenschaften stärker in den Vordergrund rückte
Ein Kernbegriff ist die aus der Soziologie stammende Agency die Handlungsmotive und -optionen betrachtet
Berücksichtigt man zusätzlich die inhärente Subjektivität jeglicher Interpretation einer Kultur von der nur die materiellen Artefakte erhalten sind setzen postprozessuale Archäologen auf hermeneutische einerseits und selbstreflektierende Praktiken andererseits
Heutige Nachfahren der zu untersuchenden Kulturen werden gleichermaßen in die Arbeit der Archäologen einbezogen wie bislang vernachlässigte soziale Perspektiven
Zusammen mit anderen Gedächtnisinstitutionen sind archäologische Funde und Ausgrabungsstätten das besonders sensible kulturelle Gedächtnis und oft wirtschaftliche Grundlage z B
Tourismus eines Staates einer Kommune oder einer Region
Gerade archäologische Funde und Ausgrabungsstätten haben auch politische Brisanz und sind in vielen bewaffneten modernen Konflikten des <num> Jahrhunderts als Teil des kulturellen Erbes eines der Primärziele und damit von Zerstörung und Plünderung bedroht
Oft soll dabei das kulturelle Erbe des Gegner nachhaltig beschädigt oder gar vernichtet werden beziehungsweise werden dabei archäologische Funde gestohlen und verbracht
Internationale und nationale Koordinationen hinsichtlich militärischer und ziviler Strukturen zum Schutz von archäologische Funde und Ausgrabungsstätten betreibt das Internationale Komitee vom Blauen Schild Association of the National Committees of the Blue Shield ANCBS mit Sitz in Den Haag
Umfangreiche Missionen dazu gab es zum Beispiel <num> in Agypten und in Libyen <num> in Syrien <num> in Mali bzw im Irak und seit <num> im Jemen
Fachgebiete
Archäologie ist ein Sammelbegriff vieler archäologischer Disziplinen welche meist bestimmte Zeitabschnitte oder Regionen bezeichnen
Die einzelnen Disziplinen unterscheiden sich nicht nur im behandelten Forschungsgegenstand sondern auch in den verwendeten Methoden z B
bei der Unterwasserarchäologie
Daneben bilden archäologische Methoden einen Teilaspekt einer eigenständigen Wissenschaft beispielsweise in der Forensik
In Fächern wie der Altamerikanistik oder auch der Klassischen Archäologie können die inhaltlichen Schwerpunkte nicht-archäologischer Natur sein
Nach Epochen und Regionen
Die Disziplinen der Archäologie unterscheiden sich thematisch zeitlich und räumlich
Dementsprechend unterschiedlich sind die Quellen derer sie sich bedienen
Während in der Prähistorischen Archäologie keine oder sehr spärlich schriftliche Quellen vorliegen und man sich vorwiegend auf die materiellen Hinterlassenschaften dieses Zeitabschnitts beruft können andere archäologische Fachrichtungen zusätzlich Schriftquellen auswerten
Prähistorische Archäologie oder Vor- Ur- und Frühgeschichte
Die Prähistorische Archäologie befasst sich mit einem Zeitraum welcher mit den ersten Steingeräten vor etwa <num> Millionen Jahren beginnt und mit der Frühgeschichte Völkerwanderungszeit Römische Kaiserzeit frühes Mittelalter und den ersten Schriftquellen endet
Provinzialrömische Archäologie
Dieses Spezialgebiet ist in der Schnittstelle zwischen der Ur- und Frühgeschichte und der Klassischen Archäologie angesiedelt
Mit den Methoden der Ur- und Frühgeschichte sind die römischen Provinzen Ziel der Forschung
Klassische Archäologie
Der Schwerpunkt der Klassischen Archäologie liegt in den Hinterlassenschaften der antiken Welt
Genauer der Griechen Etrusker und Römer in historischer Zeit etwa zwischen dem <num> Jahrtausend v Chr und dem <num> Jahrhundert n Chr Zur Klassischen Archäologie zählen auch die
Etruskologie
und die Ägäische Vorgeschichte die sich mit kykladischen minoischen und mykenischen Funden befasst
Mittelalterarchäologie oder Archäologie des Mittelalters
Die Mittelalterarchäologie beginnt fließend mit dem Ende der Frühgeschichte etwa <num> Jahrhundert und endet theoretisch mit dem Übergang zur Neuzeitarchäologie ca <num> Jahrhundert
Im Unterschied zur prähistorischen Archäologie arbeitet sie in einem Zeitraum über den in zunehmendem Maße auch Schriftquellen vorliegen
Zudem ist häufig aufgehender Baubestand vorhanden den die Archäologie des Mittelalters mit den Methoden der historischen Bauforschung Bau- oder Monumentenarchäologie untersucht
Neuzeitarchäologie
Historische Archäologie
Historische Archäologie ist ein Begriff der die Parallelüberlieferung von materiellen archäologischen Quellen und schriftlicher Überlieferung umschreibt
Er wird einerseits pragmatisch für die Archäologie des Mittelalters und der Neuzeit oder nur die der Neuzeit verwendet
Im methodologisch-phänomenologischen Sinne zielt er andererseits weltweit auf Kulturen bzw Epochen mit sogenannter dichter schriftlicher Überlieferung ab
Die nachfolgenden Disziplinen stellen geografische Schwerpunkte dar
Ägyptologie
Die Ägyptologie befasst sich mit dem antiken Ägypten etwa <num> Jahrtausend v Chr bis <num> Jahrhundert n Chr Die
Koptologie
welche die Kultur der frühen Christen in Ägypten untersucht ist ein Teilbereich der Ägyptologie
Vorderasiatische Archäologie
Dieses Fachgebiet geht aus der überwiegend philologisch ausgerichteten Altorientalistik hervor und widmet sich den alten Kulturen des Nahen Ostens im Wesentlichen das Gebiet der Türkei des Iraks des Irans Syriens Libanons Israels und Jordaniens Babylon Assyrien Sumer Akkad Elam Hethiter und Urartu aber auch mit den Nachfolgestaaten
Der untersuchte Zeitraum reicht vom <num> Jahrtausend v Chr
bis zum <num> Jahrhundert n Chr
Die Vorderasiatische Archäologie steht in enger Verbindung zur Biblischen Archäologie welche die Siedlungs- und Kulturgeschichte Palästinas erforscht und der Ägyptologie da in manchen Epochen Ägypten das Gebiet des heutigen Israel und Libanon beherrschte sich zu anderen Zeiten orientalische Reiche Ägypten einverleibten
Archäologie der Neuen Welt ein Teilgebiet der Altamerikanistik
Spezialgebiete
DateiVorgeschichtlicher korbjpg
Nach Phasen und Aspekten der kulturellen Entwicklung
Primatenarchäologie früheste Phase der Menschheit erste Werkzeuge
Siedlungsarchäologie ab dem Neolithikum
Montanarchäologie Bergbau und Hüttenwesen ab der Bronzezeit
Christliche Archäologie vor allem Spätantike
Kirchenarchäologie
Rechtsarchäologie vor allem Mittelalter
Industriearchäologie
Nach besonderen Fundplätzen
Gletscherarchäologie
Küstenarchäologie
Schlachtfeldarchäologie Zeithorizont Bronzezeit bis <num> Jahrhundert
Stadtarchäologie Grabungen in heutigen Städten
Trassenarchäologie entlang von Bahn- Kanal- Leitungs- und Straßenbaumaßnahmen
Unterwasserarchäologie
Besondere Untersuchungsgegenstände
Textilarchäologie Kleidung
Musikarchäologie Musikinstrumente
Besondere Fragestellungen
Kognitive Archäologie Frage nach dem damaligen Bewusstsein
Archäologische Geschlechterforschung Frage nach den damaligen Rollen der Geschlechter
Besondere Methoden
Archäoinformatik Einsatz moderner Datenverarbeitung
Archäometrie Einsatz moderner naturwissenschaftlicher Methoden
Geoarchäologie Einsatz geowissenschaftlicher Methoden
Luftbildarchäologie
Experimentelle Archäologie
Hilfswissenschaften
Archäozoologie und Archäobotanik Schnittstelle zur Biologie
Analyse von Tierknochen- Pollen- und Pflanzenfunden um die Umweltbedingungen zu rekonstruieren
Zu den Untersuchungsobjekten gehören Bodenproben ebenso wie Mageninhalte Abfallgruben und Latrinen
Paläopathologie Schnittstelle zur Medizin
Paläopathologen führen medizinische Untersuchungen an menschlichen Knochen und Geweben durch um Alter und Geschlecht der Individuen zu bestimmen und auf ihren Gesundheitszustand zu schließen
Die Paläopathologie ermöglicht Erkenntnisse über Lebensbedingungen Ernährungsgewohnheiten und Krankheiten
Des Weiteren sind Rückschlüsse auf die medizinische Versorgung und den sozialen Zusammenhalt unserer Vorfahren möglich
Archäoastronomie oder Astroarchäologie auch Paläoastronomie Schnittstelle zur Astronomie
Zur Analyse prähistorischer Kultstätten wird die Archäoastronomie benötigt
Beispielsweise werden die Sonnwendpunkte einer bestimmten Zeit berechnet um die mögliche astronomische Bedeutung von Fundstätten zu erschließen
Historische Bauforschung Schnittstelle zur Architektur
Nachbardisziplinen
Geschichtswissenschaft
Anthropologie
Paläontologie
Geophysik
Numismatik
Epigraphik
Paläographie
Philologie
Historische Klimatologie und Paläoklimatologie
Forschungsmethoden
Archäologische Forschungsmethoden gliedern sich in solche der Quellenerschließung und solche der Interpretation
In der Öffentlichkeit wird meist nur die Erschließung der Quellen zur Kenntnis genommen
Zur Quellenerschließung zählt auch die typologische und chronologische Auswertung
Erst nach der Quellenerschließung und Aufbereitung folgt die historische Interpretation
Quellenerschließung
Die Ausgrabung ist zwar die bekannteste Forschungsmethode jedoch nur ein kleiner Teilbereich der archäologischen Arbeit
Die Dokumentation Auswertung Konservierung und Archivierung der Funde stellt den weitaus größten Teil der archäologischen Tätigkeit dar
Außerdem muss die Grabung sorgfältig vorbereitet werden
Prospektion und Voruntersuchungen
Die Prospektion umfasst zerstörungsfreie Methoden mit deren Hilfe eine Untersuchung potenzieller oder bekannter Fundplätze ermöglicht wird
Dazu gehören die Geländebegehung Survey die Luftbildarchäologie und geophysikalische Methoden Geoelektrik elektromagnetische Induktion geomagnetische Kartierung sowie Bodenradar und LIDAR
Ebenfalls prospektiv einsetzen lässt sich die Phosphatanalyse
Eingeleitet wird eine Ausgrabung durch archäologische Voruntersuchungen
Zum Einsatz kommen hier Suchgräben magnetische Sondierung Bodenwiderstandsmessung Luftbilder und andere Methoden der Bodenforschung
Die Voruntersuchungen dienen dazu sich ein Bild der potenziellen Grabungsstelle zu machen um die eigentliche Grabung besser planen zu können
Ausgrabung
DateiArchäologie schichtengrabungjpg Die meisten Fundplätze werden heute durch Baumaßnahmen entdeckt
Über Notgrabungen auch Rettungsgrabungen genannt versucht die archäologische Denkmalpflege diese Befunde vor ihrer endgültigen Zerstörung auszuwerten
Seltener sind Forschungsgrabungen bei denen unter primär wissenschaftlichen Interessen Fundplätze zur Grabung ausgewählt und ohne äußeren Zeitdruck untersucht werden können
Bei der Grabung werden verschiedene Grabungstechniken angewandt
Eine moderne Grabung ist befundorientiert d h
die Funde werden in ihrer räumlichen und zeitlichen Einbettung auf Befunde bezogen
Da jede Ausgrabung zur Zerstörung eines Befundes führt soll eine exakte Dokumentation den Fundplatz zumindest auf dem Papier auch später bis ins Detail rekonstruierbar machen
Die wichtigsten Arbeitsmittel der Ausgrabung sind deshalb neben der Kelle Papier und Buntstift
Bauforschung
Die Bauforschung ist ein wesentlicher Teil sowohl der klassischen Archäologie als auch der Archäologie des Mittelalters wohingegen sie in der Ur- und Frühgeschichte mangels aufgehend erhaltener Bauwerke nur eine untergeordnete Rolle spielt
Eine der Dokumentationsmethoden ist die Photogrammetrie
Auswertung
Gerade am sehr populären Beispiel der Gletschermumie Ötzi ist zu erkennen dass die Ausgrabung nur einen Bruchteil der archäologischen Arbeit darstellt
Der <num> entdeckte Fund wird bis heute wissenschaftlich untersucht
Typologie
Die Typologie ist die Klassifikation von Objekten nach Kriterien von Form und Material
Sie ist grundlegend für die Einordnung des Fundmaterials da sie Vergleiche mit Fundsituationen an anderen Fundplätzen ermöglicht und zur Grundlage von Kombinationsanalysen zur relativchronologischen Datierung wie zur sozioökonomischen Einordnung und Verbreitungsanalysen wird
Materialbestimmungen
Wie bei der Prospektion und der Altersbestimmung werden auch für Materialbestimmungen moderne naturwissenschaftliche Techniken eingesetzt siehe Archäometrie
Zur Identifikation und Detailuntersuchung von Artefakten dienen u a die Mikroskopie Infrarot- und Ultraschallaufnahmen Röntgen chemische Analysen Spektralanalysen und Laserscans
Altersbestimmung
DateiDendrochronologiejpg Ein Schwerpunkt der Fundanalyse ist die Datierung der Befunde z B
Grab anhand der Funde z B
Grabbeigabe
Bei der Altersbestimmung wird zwischen absoluter Chronologie und relativer Chronologie unterschieden
Die relative Chronologie setzt einen Fund dabei in Bezug zu einem anderen
Ist er jünger älter oder gar gleichzeitig
JJ
Winckelmanns vergleichendes Sehen ist eine der ersten Methoden zur relativen Chronologie
Fundkombination von geschlossenen Funden siehe auch Seriation und Korrespondenzanalyse
Chorologie
Stratigraphie
Bei der absoluten Chronologie wird ein Fund ein absolutes Datum Jahr Jahrhundert zugeordnet
C-Datierung für organische Stoffe
Thermolumineszenzdatierung auch TL-Datierung für Keramik
Dendrochronologie für Holz
Kalium-Argon-Methode für Gestein
Interpretation
Die Methoden der Interpretation sind in der Regel eher geisteswissenschaftlich
Für die prähistorische Archäologie ist der Analogieschluss die wesentliche Möglichkeit der Interpretation
In der historischen Archäologie z B
Klassische Archäologie oder Archäologie des Mittelalters ist es der Vergleich mit Informationen aus anderen Quellen wie schriftlicher oder bildlicher Überlieferung
Funde
Archäologie in Deutschland
In Deutschland gehört die Archäologie zu den Aufgaben der Bundesländer Landesarchäologe meist als Bereich des Denkmalamtes als Bodendenkmalpflege organisiert
Größere Städte haben oft eine eigene Stadtarchäologie
Mehrere Institutionen fördern Forscher und Projekte durch Archäologiepreise
Deutsche Grabungen im Ausland werden hingegen im Rahmen von Forschungsprojekten der Universitäten des Deutschen Archäologischen Instituts oder des Römisch-Germanischen Zentralmuseums durchgeführt
Archäologie außerhalb Europas
Archäologie in Amerika
Die Archäologie gehört in Amerika zur Anthropologie Völkerkunde und hat aus diesem Grund eine völlig andere Ausrichtung als die europäische Forschung
Dies folgt vor allem aus dem Umstand dass zum Zeitpunkt der Besiedlung der neuen Welt zuerst ethnographische Untersuchungen an noch existierenden Ureinwohnern stattfanden
Die eher spärlichen präkolumbischen Funde sind ein weiterer Grund für den in der Erforschung kultureller Prozesse liegenden Schwerpunkt amerikanischer Archäologie
Als Pionier der amerikanischen Archäologie gilt Thomas Jefferson <num>-<num> welcher ab <num> einige Grabhügel untersucht um ihr Alter zu bestimmen
Jefferson setzt dabei erstmals eine Methode ein die als Vorläufer der Dendrochronologie angesehen werden kann er zählt die Jahresringe der auf den Grabhügeln stehenden Bäume
Die ersten großen Ausgrabungen in Mittelamerika werden Ende des <num> Jahrhunderts im Mayazentrum Copán durchgeführt
<num> entdeckt Hiram Bingham die Inkastadt Machu Picchu
Im Jahre <num> fanden Archäologen in der Nähe von Mexiko-Stadt über <num> Artefakte aus der Zeit der spanischen Eroberung des Landes
Man fand nicht nur menschliche Knochen sondern auch Waffen Kleidung Haushaltsgeräte und Gegenstände aus dem persönlichen Besitz von Hernán Cortés
Die Fundstelle Tecoaque vorspanischer Name Zultepec wurde als Weltkulturerbe vorgeschlagen
Archäologie in Indien und China
<num> wird in Indien die Archaeological Survey of India gegründet
<num><num> entdeckt man eine der ältesten Hochkulturen der Menschheit die Indus-Kultur
Ausgegraben werden u a die Städte Harappa und Mohenjo-Daro
Archäologie in China beginnt mit dem schwedischen Geologen J Gunnar Andersson <num>-<num> der <num> bei Yang Shao Tsun in Honan eine neolithische Wohnhöhle entdeckt und damit beweist dass China in vorgeschichtlicher Zeit bewohnt war
<num> wird Anyang ausgegraben die Hauptstadt der Shang-Dynastie des <num> Jahrtausends v Chr
<num> wird die Terrakottaarmee rund um das Grab des chinesischen Kaisers Qin Shihuangdi bei Xian entdeckt
Archäologie in Afrika
Afrika ist nicht nur in paläoanthropologischer Hinsicht die Wiege der Menschheit sondern auch die unserer Kultur
Nur in Afrika kommen Steingeräte vor die <num> Millionen Jahre alt sind und deren Herstellung mit den ersten Homo-Arten unserer Spezies in Verbindung gebracht wird
Die betreffenden Werkzeuge - einfache Geröllgeräte vom Oldowan-Typ später die Faustkeile um die Leitformen zu nennen - kommen auch in anderen Teilen der Welt vor nur sind sie dort deutlich jünger
In Europa datieren die ältesten Stellen auf eine Million Jahre
Neue etwa <num> Millionen Jahre alte Funde in Lomekwi <num> Kenia werden als Beleg für eine eigenständige archäologische Kultur interpretiert vorschlagsweise Lomekwian genannt
Bereits seit dem <num> Jahrhundert ist der Nordosten Afrikas Gegenstand intensiver Forschungen durch die Ägyptologie und Koptologie
Diese Region des Kontinents ist auch im internationalen Vergleich hervorragend dokumentiert
Da jedoch die ältesten Schriftquellen im subsaharischen Afrika nicht weiter als <num> Jahre zurückreichen kommt der Archäologie gerade hier eine besondere Bedeutung zu
Aufgrund der kurzen Forschungstradition im Vergleich zu Mitteleuropa steht man hier allerdings noch vielfach am Anfang
Aufbereitung für die Öffentlichkeit und Schutz
Die Vermittlung archäologischer Forschungsergebnisse erfolgt auf verschiedene Weise
durch Fachbücher und Fachzeitschriften
durch populärwissenschaftliche Publikationen
in Museen vgl
im Gelände Oberirdisch sichtbare Bodendenkmäler können durch Ausschilderung oder im Rahmen eines Wanderlehrpfades erschlossen werden vgl Archäologische Wanderung wie zum Beispiel der Archäologisch-naturkundliche Wanderweg Lübeck
In einem Archäologischen Park treten zumeist Rekonstruktionen hinzu
Rekonstruktionen oder der Wiederaufbau sind wissenschaftlich sehr umstritten da eine Rekonstruktion immer spekulativ ist und nur den aktuellen Wissensstand widerspiegelt
Zudem oftmals gefärbt durch den herrschenden Zeitgeist
Es ergeben sich jedoch auch Schnittstellen zur Experimentellen Archäologie indem die Machbarkeit und der Praxisbezug einer Theorie überprüft werden können
durch Führungen
durch museumsdidaktische Vorführungen meist als Experimentelle Archäologie deklariert
Vielerorts bestehen regionale Gesellschaften und Vereine die sich der Archäologie widmen und entsprechende Aktionen tragen siehe Liste der Archäologischen Gesellschaften in Deutschland
Zunehmend wird international auch der Schutz der archäologischen Funde für die Öffentlichkeit im Hinblick auf Katastrophen Kriege und bewaffnete Auseinandersetzungen durchgesetzt
Das geschieht einerseits durch internationale Abkommen und andererseits durch Organisationen die den Schutz überwachen beziehungsweise durchsetzen
Als weltweites Beispiel gilt Blue Shield International mit seinen Archäologen und lokalen Partnerorganisationen
Die Wichtigkeit der archäologischen Funde im Bezug auf Identität Tourismus und nachhaltiges Wirtschaftswachstum werden immer wieder betont
So wurde auch vom Präsident von Blue Shield International Karl von Habsburg bei einem Kulturgutschutz-Einsatz im April <num> im Libanon mit der United Nations Interim Force in Lebanon erläuterte Kulturgüter sind ein Teil der Identität der Menschen die an einem bestimmten Ort leben
Zerstört man ihre Kultur so zerstört man damit auch ihre Identität
Viele Menschen werden entwurzelt haben oft keine Perspektiven mehr und flüchten in der Folge aus ihrer Heimat
Archäologische Institute
Film
Unter dem Boden ein Film von Erich Langjahr
Literatur
Buchpublikationen
chronologisch sortiert
Einführungen
Hans Jürgen Eggers Einführung in die Vorgeschichte Piper München <num> <num> Neuaufl
scrîpvaz Berlin <num>
ISBN <num>-<num>-<num>-<num> Nachdruck des Werks von <num> daher nur die traditionellen Methoden neue Ansätze fehlen
Johannes Bergemann Orientierung Archäologie - was sie kann was sie will Rowohlt Reinbek bei Hamburg <num>
ISBN <num>-<num>-<num>-X Klassische Archäologie
Colin Renfrew Paul G Bahn Archaeology - Theories Methods and Practice
<num> Auflage London <num> ISBN <num>-<num>-<num>-<num>-<num> gute englischsprachige Einführung gekürzte deutsche Übersetzung von Helmut Schareika Basiswissen Archäologie
Theorien - Methoden - Praxis
Philipp von Zabern Mainz <num> ISBN <num>-<num>-<num>-<num>-<num>
Manfred K H Eggert Prähistorische Archäologie
Konzepte und Methoden
<num> überarb
Aufl UTB Francke Tübingen Basel <num>
ISBN <num>-<num>-<num>-<num>-<num>
Manfred K H Eggert Stefanie Samida Ur- und frühgeschichtliche Archäologie <num> Aufl UTB Tübingen <num>
ISBN <num>-<num>-<num>-<num>-<num>
Barbara Scholkmann - Hauke Kenzler - Rainer Schreg Hrsg Archäologie des Mittelalters und der Neuzeit
Grundwissen Darmstadt Wiss Buchgesellschaft <num> ISBN <num>
Überblick
Paul G Bahn Hrsg Archaeology
Cambridge Illustrated History
Cambridge University Press Cambridge <num>
ISBN <num>-<num>-<num>-<num>
Reinhard Bernbeck Theorien in der Archäologie UTB Wissenschaft Band <num>
Francke Verlag Tübingen Basel <num> ISBN <num>-<num>-<num>-X ISBN <num>-<num>-<num>-<num>
Marion Benz Christian Maise Archäologie Theiss Stuttgart <num>
ISBN <num>-<num>-<num>-<num>
Manfred K H Eggert Archäologie
Grundzüge einer Historischen Kulturwissenschaft
Francke Tübingen <num>
ISBN <num>-<num>-<num>-<num>
Der Brockhaus Archäologie
Hochkulturen Grabungsstätten Funde
FA
Brockhaus MannheimLeipzig <num> ISBN <num>-<num>-<num>-<num>-<num>
Alain Schnapp Die Entdeckung der Vergangenheit
Ursprünge und Abenteuer der Archäologie
aus dem Französischen von Andreas Wittenburg
Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> Rezension von Lutz Bunk Archäologische Detektivarbeit
Jeorjios Martin Beyer Archäologie
Von der Schatzsuche zur Wissenschaft
Philipp von Zabern Mainz <num> ISBN <num>-<num>-<num>-<num>-<num>
Matthias Knaut Roland Schwab Hrsg Archäologie im <num> Jahrhundert
Innovative Methoden - bahnbrechende Ergebnisse
Konrad Theiss Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Geoffrey John Tassie Lawrence Stewart Owens Standards of Archaeological Excavations A Fieldguide to the Methology Recording Techniques and Conventions London <num> ISBN <num>-<num>-<num>-<num>-<num>
Marco Kircher Wahre Archäologie
Die Medialisierung archäologischen Wissens im Spannungsfeld von Wissenschaft und Öffentlichkeit Reihe Historische Lebenswelten
transcript
Verlag für Kommunikation Kultur und soziale Praxis Bielefeld <num> ISBN <num>-<num>-<num>-<num>-<num>
Aedeen Cremin Große Enzyklopädie der Archäologie
Die wichtigsten archäologischen Stätten der Welt
Konrad Theiss Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
Bruce Trigger A History of Archaeological Thought
Cambridge University Press Cambridge <num>
ISBN <num>-<num>-<num>-<num>
S Wolfram und U Sommer Macht der Vergangenheit - Wer macht Vergangenheit
Archäologie und Politik
In Beiträge zur Ur- und Frühgeschichte Mitteleuropas
Band <num> Beier
Beran Wilkau-Hasslau <num>
Archäologie in Deutschland
Martin Kuckenburg Siedlungen der Vorgeschichte in Deutschland <num> <num> bis <num> v Chr DuMont Köln <num>
ISBN <num>-<num>-<num>-<num>
Wilfried Menghin Dieter Planck Hrsg Menschen Zeiten Räume Archäologie in Deutschland Theiss Stuttgart <num>
ISBN <num>-<num>-<num>-<num>
Uta von Freeden Siegmar von Schnurbein Hrsg Spuren der Jahrtausende
Archäologie und Geschichte in Deutschland
Theiss Stuttgart <num>
ISBN <num>-<num>-<num>-<num> Zusammen mit dem nächsten Band die Leistungsschau der deutschen Landesarchäologien
Archäologie in Europa
Barry Cunliffe Illustrierte Vor- und Frühgeschichte Europas Campus FrankfurtMain <num>
ISBN <num>-<num>-<num>-<num>
Schriftenreihen
Grazer altertumskundliche Studien Verlag Peter Lang Frankfurt am Main u a
Archäologische Berichte der Deutschen Gesellschaft für Ur- und Frühgeschichte
Archäologische Zeitschriften
Wörterbücher
Heinrich Otte Archäologisches Wörterbuch zur Erklärung der in den Schriften über christliche Kunstalterthümer vorkommenden Kunstausdrücke Deutsch Lateinisch Französisch und Englisch Leipzig <num> Reprint der Originalausgabe durch Reprint-Verlag Leipzig <num> ISBN <num>-<num>-<num>-<num>
Online-Publikationen
Guido Nockemann The DAS Project - Digitization of an archaeological collection <num> e-paper for the Day Of Archaeology <num> englisch
Literaturrecherche
Propylaeum Fachinformationsdienst Altertumswissenschaften
Weblinks
Internet-Portal zur Archäologie Der mit großem Abstand umfangreichste deutschsprachige Zugang zur Archäologie im Internet wird ständig aktualisiert
Onlineportal zur Prähistorischen Archäologie
Onlineportal mit umfangreicher Wissensdatenbank zur prähistorischen Archäologie
Nützliches für Grabungstechnik und Archäologie
Weblog über Archäologie
Datenbank mit Literatur- und Linkhinweisen für archäologische und geschichtliche Themen
Bibliographie zum Raub an archäologischen Stätten University at Buffalo
Luftbildarchäologie Bilder
Experimentelle Archäologie Archeoparagliding Rekonstruktionen Website von Marek Poznański
Vereine und Organisationen
Deutscher Archäologen-Verband
Deutsches Archäologisches Institut
Deutsche Gesellschaft für Ur- und Frühgeschichte e V
DGUF
Stiftung Archäologie
Liste aller Landesämter für Archäologie in Deutschland
Archäologische Gesellschaft Innsbruck Website der Archäologischen Gesellschaft Innsbruck
Archäologiemuseen bei webmuseende
wwwexarorg EXAR - Europäische Vereinigung zur Förderung der Experimentellen Archäologie e V
EXARC European EXchange on Archaeological Research and Communication Zusammenschluss europäischer Institutionen zur Experimentellen Archäologie
AG Computeranwendungen und Quantitative Methoden in der Archäologie Arbeitsgruppe Archäologie und Archäobotanik Afrikas im Institut für Archäologische Wissenschaften der Goethe-Universität Frankfurt
Webseite zur Bodendenkmalpflege in Krefeld Dachverband Archäologischer Studierendenvertretungen Liste der in Österreich tätigen Grabungsfirmen und Institutionen
Einzelnachweise
Vgl M K H Eggert Archäologie Grundzüge einer Historischen Kulturwissenschaft TübingenBasel <num> UTB <num> Hansjürgen Müller-Beck Die Steinzeit - Der Weg der Menschen in die Geschichte CH Beck München <num> S <num> Vgl Homepage des US Committee of the Blue Shield abgerufen am <num> Oktober <num> Isabelle-Constance v Opalinski Schüsse auf die Zivilisation In
FAZ
<num> August <num> Hans Haider Missbrauch von Kulturgütern ist strafbar In Wiener Zeitung <num> Juni <num> Aisling Irwin
A no-strike list may shield Yemens ancient treasures from war
In
New Scientist Daily news
vom <num> Januar <num> abgerufen am <num> September <num> Jyot Hosagrahar Culture at the heart of SDGs UNESCO-Kurier April-Juni <num> Rick Szostak The Causes of Economic Growth Interdisciplinary Perspectives Springer Science
Business Media <num> ISBN <num> Corine Wegener Marjan Otter Cultural Property at War Protecting Heritage during Armed Conflict In The Getty Conservation Institute Newsletter <num> Spring <num>
Der
ASCII alternativ US-ASCII oft
ausgesprochen
ist eine <num>-Bit-Zeichenkodierung sie entspricht der US-Variante von ISO <num> und dient als Grundlage für spätere auf mehr Bits basierende Kodierungen für Zeichensätze
Der ASCII-Code wurde zuerst am <num> Juni <num> von der American Standards Association ASA als Standard ASA X<num>-<num> gebilligt
und <num><num> wesentlich sowie zuletzt im Jahr <num> ANSI X<num>-<num> von ihren Nachfolgeinstitutionen aktualisiert und wird bis heute noch benutzt
Die Zeichenkodierung definiert <num> Zeichen bestehend aus <num> nicht druckbaren sowie <num> druckbaren Zeichen
Druckbare Zeichen sind beginnend mit dem Leerzeichen
-<num>< >ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz
lateinische Alphabet
arabischen Ziffern
Interpunktionszeichen
Satzzeichen
Wortzeichen
Sonderzeichen
Tastatur
Schreibmaschine
englische Sprache
abwärtskompatibel
ISO <num>
Unicode
Die nicht druckbaren Steuerzeichen enthalten Ausgabezeichen wie Zeilenvorschub oder Tabulatorzeichen Protokollzeichen wie Übertragungsende oder Bestätigung und Trennzeichen wie Datensatztrennzeichen
Kodierung
Jedem Zeichen wird ein Bitmuster aus <num> Bit zugeordnet
Da jedes Bit zwei Werte annehmen kann gibt es <num>
<num> verschiedene Bitmuster die auch als die ganzen Zahlen <num>-<num> hexadezimal <num>h-<num>Fh interpretiert werden können
Das für ASCII nicht benutzte achte Bit kann für Fehlerkorrekturzwecke Paritätsbit auf den Kommunikationsleitungen oder für andere Steuerungsaufgaben verwendet werden
Heute wird es aber fast immer zur Erweiterung von ASCII auf einen <num>-Bit-Code verwendet
Diese Erweiterungen sind mit dem ursprünglichen ASCII weitgehend kompatibel so dass alle im ASCII definierten Zeichen auch in den verschiedenen Erweiterungen durch die gleichen Bitmuster kodiert werden
Die einfachsten Erweiterungen sind Kodierungen mit sprachspezifischen Zeichen die nicht im lateinischen Grundalphabet enthalten sind vgl unten
Zusammensetzung
Die ersten <num> ASCII-Zeichencodes von <num>hex bis <num>Fhex sind für Steuerzeichen control character reserviert siehe dort für die Erklärung der Abkürzungen in obiger Tabelle
Diese Zeichen stellen keine Schriftzeichen dar sondern dienen oder dienten zur Steuerung von solchen Geräten die den ASCII verwenden etwa Drucker
Steuerzeichen sind beispielsweise der Wagenrücklauf für den Zeilenumbruch oder
Bell
die Glocke ihre Definition ist historisch begründet
Code <num>hex SP ist das Leerzeichen engl space oder blank das in einem Text als Leer- und Trennzeichen zwischen Wörtern verwendet und auf der Tastatur durch die Leertaste erzeugt wird
Die Codes <num>hex bis <num>Ehex stehen für druckbare Zeichen die Buchstaben Ziffern und Interpunktionszeichen Satzzeichen Wortzeichen umfassen
Die Buchstaben sind lediglich Klein- und Großbuchstaben des lateinischen Alphabets
In nicht-englischen Sprachen verwendete Buchstabenvarianten - beispielsweise die deutschen Umlaute - sind im ASCII-Zeichensatz nicht enthalten
Ebenso fehlen typografisch korrekte Gedankenstriche und Anführungszeichen die Typografie beschränkt sich auf den Schreibmaschinensatz
Der Zweck war Informationsaustausch nicht Drucksatz
Code <num>Fhex alle sieben Bits auf eins gesetzt ist ein Sonderzeichen das auch als Löschzeichen bezeichnet wird DEL
Dieser Code wurde früher wie ein Steuerzeichen verwendet um auf Lochstreifen oder Lochkarten ein bereits gelochtes Zeichen nachträglich durch das Setzen aller Bits das heißt durch Auslochen aller sieben Markierungen löschen zu können
Dies war die einzige Möglichkeit zum Löschen da einmal vorhandene Löcher nicht mehr rückgängig gemacht werden können
Bereiche ohne Löcher also mit dem Code <num>hex fanden sich vor allem am Anfang und Ende eines Lochstreifens NUL
Aus diesem Grund gehörten zum eigentlichen ASCII nur <num> Zeichen denn den Bitmustern <num> <num> und <num> <num> entsprachen keine Zeichencodes
Der Code <num> wurde später in der Programmiersprache C als Ende der Zeichenkette interpretiert dem Zeichen <num> wurden verschiedene grafische Symbole zugeordnet
Geschichte
Fernschreiber
Eine frühe Form der Zeichenkodierung war der Morsecode
Er wurde mit der Einführung von Fernschreibern aus den Telegrafennetzen verdrängt und durch den Baudot-Code und Murray-Code ersetzt
Vom <num>-Bit-Murray-Code zum <num>-Bit-ASCII war es dann nur noch ein kleiner Schritt - auch ASCII wurde zuerst für bestimmte amerikanische Fernschreibermodelle wie den Teletype ASR<num> eingesetzt
Die erste Version noch ohne Kleinbuchstaben und mit kleinen Abweichungen vom heutigen ASCII bei den Steuer- und Sonderzeichen entstand im Jahr <num>
<num> wurde dann die bis heute gültige Fassung des ASCII-Standards festgelegt Diese Fassung gebar die Caesar-Verschlüsselung ROT<num> als Erweiterung von ROT<num>
Während ROT<num> nur das lateinische Alphabet um dessen halbe Länge rotiert rotiert ROT<num> alle ASCII-Zeichen zwischen <num>
und <num>
Computer
In den Anfängen des Computerzeitalters entwickelte sich ASCII zum Standard-Code für Schriftzeichen
Zum Beispiel wurden viele Terminals VT<num> und Drucker nur mit ASCII angesteuert
Für die Kodierung lateinischer Zeichen wird fast nur bei Großrechnern die zu ASCII inkompatible <num>-Bit-Kodierung EBCDIC verwendet die IBM parallel zu ASCII für sein System<num> entwickelte damals ein ernsthafter Konkurrent
Die Handhabung des Alphabets ist in EBCDIC schwieriger denn es ist dort auf zwei auseinander liegende Codebereiche verteilt
IBM selbst verwendete ASCII für interne Dokumente
ASCII wurde durch Präsident Lyndon B Johnsons Anordnung <num> gestützt es in den Regierungsbüros zu verwenden
Verwendung für andere Sprachen
Mit dem Internationalen Alphabet <num> IA<num> wurde <num> eine <num>-Bit-Codierung auf Basis des ASCII als ISO <num> normiert
Die Referenzversion ISO <num>-IRV entspricht dabei bis auf eine Position dem ASCII
Um Buchstaben und Sonderzeichen verschiedener Sprachen darstellen zu können beispielsweise die deutschen Umlaute wurden <num> Zeichenpositionen zur Umdefinition vorgesehen
Eine gleichzeitige Darstellung ist nicht möglich
Fehlende Anpassungen der Software an die jeweils zur Anzeige verwendete Variante führte oft zu ungewollt komischen Ergebnissen z B
erschien beim Einschalten des Apple II APPLE ÜÄ anstelle von APPLE
Da sich darunter Zeichen befinden die in der Programmierung verwendet werden insbesondere z B
die verschiedenen Klammern wurden Programmiersprachen über Ersatzkombinationen Digraphen für die Internationalisierung ertüchtigt
Zur Kodierung wurden dazu ausschließlich Zeichen aus dem invarianten Teil von ISO <num> verwendet
Die Kombinationen sind sprachspezifisch
So entspricht bei Pascal
und
den geschweiften Klammern
während C
und
dafür vorsieht
Erweiterungen
Nutzung der übrigen <num> Positionen im Byte
Zur Überwindung der Inkompatibilitäten nationaler <num>-Bit-Varianten von ASCII entwickelten zunächst verschiedene Hersteller eigene ASCII-kompatible <num>-Bit-Codes d h
solche die auf den ersten <num> Positionen mit ASCII übereinstimmen
Der Codepage <num> genannte Code war lange Zeit der am weitesten verbreitete er kam auf dem IBM-PC unter englischem MS-DOS und kommt heute noch im DOS-Fenster von englischem Microsoft Windows zur Anwendung
In deren deutschen Installationen ist seit MS-DOS <num> die westeuropäische Codepage <num> der Standard
Auch bei späteren Standards wie ISO <num> wurden acht Bits verwendet
Dabei existieren mehrere Varianten zum Beispiel
ISO <num>-<num>
für die westeuropäischen Sprachen die in Deutschland als DIN <num> übernommen wurde
Deutschsprachige Versionen von Windows außer DOS-Fenster verwenden die auf ISO <num>-<num> aufbauende Kodierung Windows-<num> - daher sehen zum Beispiel die deutschen Umlaute falsch aus wenn Textdateien unter DOS erstellt wurden und unter Windows betrachtet werden
Jenseits von <num> Bit
Viele ältere Programme die das achte Bit für eigene Zwecke verwendeten konnten damit nicht umgehen
Sie wurden im Lauf der Zeit oft den neuen Erfordernissen angepasst
Auch <num>-Bit-Codes in denen ein Byte für ein Zeichen stand boten zu wenig Platz um alle Zeichen der menschlichen Schriftkultur gleichzeitig unterzubringen
Dadurch wurden mehrere verschiedene spezialisierte Erweiterungen notwendig
Daneben existieren vor allem für den ostasiatischen Raum einige ASCII-kompatible Kodierungen die entweder zwischen verschiedenen Codetabellen umschalten oder mehr als ein Byte für jedes Nicht-ASCII-Zeichen benötigen Keine dieser <num>-Bit-Erweiterungen ist aber ASCII denn das bezeichnet nur den einheitlichen <num>-Bit-Code
Um den Anforderungen der verschiedenen Sprachen gerecht zu werden wurde der Unicode in seinem Zeichenvorrat identisch mit
ISO <num>
entwickelt
Er verwendet bis zu <num> Bit pro Zeichen und könnte somit über vier Milliarden verschiedene Zeichen unterscheiden wird jedoch auf etwa eine Million erlaubte Codepoints eingeschränkt
Damit können alle bislang von Menschen verwendeten Schriftzeichen dargestellt werden sofern sie in den Unicode-Standard aufgenommen wurden
UTF-<num> ist eine <num>-Bit-Kodierung von Unicode die zu ASCII abwärtskompatibel ist
Ein Zeichen kann dabei ein bis vier <num>-Bit-Wörter einnehmen
Sieben-Bit-Varianten müssen nicht mehr verwendet werden dennoch kann Unicode auch mit Hilfe von UTF-<num> in sieben Bit kodiert werden
UTF-<num> entwickelte sich zum Standard unter vielen Betriebssystemen
So nutzen unter anderem Apples macOS sowie einige Linux-Distributionen standardmäßig UTF-<num> und mehr als <num> der Websites werden in UTF-<num> erstellt
Formatierungszeichen gegenüber Auszeichnungssprachen
ASCII enthält nur wenige Zeichen die allgemeinverbindlich zur Formatierung oder Strukturierung von Text verwendet werden diese gingen aus den Steuerbefehlen der Fernschreiber hervor
Dazu zählen insbesondere der Zeilenvorschub Linefeed der Wagenrücklauf Carriage Return das Horizontal-Tabulatorzeichen der Seitenvorschub Form Feed und das Vertikal-Tabulatorzeichen
In typischen ASCII-Textdateien findet sich neben den druckbaren Zeichen meist nur noch der Wagenrücklauf oder der Zeilenvorschub um das Zeilenende zu markieren dabei werden in DOS- und Windows-Systemen üblicherweise beide nacheinander verwendet bei älteren Apple- und Commodore-Rechnern ohne Amiga nur der Wagenrücklauf und auf Unix-artigen sowie Amiga-Systemen nur der Zeilenvorschub
Die Verwendung weiterer Zeichen zur Textformatierung wird unterschiedlich gehandhabt
Zur Formatierung von Text werden inzwischen eher Markup-Sprachen wie zum Beispiel HTML verwendet
Kompatible Zeichenkodierungen
Die meisten Zeichenkodierungen sind so entworfen dass sie für Zeichen zwischen <num>
<num> den gleichen Code verwenden wie ASCII und den Bereich über <num> für weitere Zeichen benutzen
Kodierungen mit fester Länge Auswahl
Hier steht eine feste Anzahl Bytes für jeweils ein Zeichen
In den meisten Kodierungen ist das ein Byte pro Zeichen - Single Byte Character Set oder kurz SBCS genannt
Bei den ostasiatischen Schriften sind es zwei oder mehr Byte pro Zeichen wodurch diese Kodierungen nicht mehr ASCII-kompatibel sind
Die kompatiblen SBCS-Zeichensätze entsprechen den oben besprochen ASCII-Erweiterungen
ISO <num> mit <num> verschiedenen Zeichenkodierungen zur Abdeckung aller europäischen Sprachen Türkisch Arabisch Hebräisch sowie Thai siehe Tabelle rechts
MacRoman MacCyrillic und andere proprietäre Zeichensätze für Apple Mac Computer vor Mac OS X
DOS-Codepages z B
<num> <num> und Windows-Codepages z B
Windows-<num>
KOI<num>-R für Russisch und KOI<num>-U für Ukrainisch
ARMSCII-<num> und ARMSCII-<num>a für Armenisch
GEOSTD für Georgisch
ISCII für alle indischen Sprachen
TSCII für Tamil
Kodierungen mit variabler Länge
Um mehr Zeichen kodieren zu können werden die Zeichen <num> bis <num> in einem Byte kodiert andere Zeichen werden durch mehrere Bytes mit Werten von über <num> kodiert
UTF-<num> und GB <num> für Unicode
ISO <num> für europäische Sprachen mit lateinischer Schrift
Big<num> für traditionelles Chinesisch Republik China Taiwan Auslandschinesen
EUC Extended UNIX Coding für mehrere ostasiatische Sprachen
GB Guojia Biaozhun für vereinfachtes Chinesisch VR China
ASCII-Tabelle
Die folgende Tabelle gibt neben den hexadezimalen Codes auch noch die Dezimal- und Oktalcodes an
Eponyme
Der <num> entdeckte Asteroid <num> ASCII wurde <num> nach der Zeichenkodierung benannt
Siehe auch
ASCII-Art
CBM-ASCII
Bob Bemer
Fieldata
Ausgaben
American Standards Association American Standard Code for Information Interchange
ASA X<num>-<num>
American Standards Association New York <num>
American Standards Association American Standard Code for Information Interchange
ASA X<num>-<num>
American Standards Association New York <num> genehmigt aber nicht veröffentlicht
United States of America Standards Institute USA Standard Code for Information Interchange
USAS X<num>-<num>
United States of America Standards Institute <num>
United States of America Standards Institute USA Standard Code for Information Interchange
USAS X<num>-<num>
United States of America Standards Institute <num>
American National Standards Institute American National Standard for Information Systems
ANSI X<num>-<num>
<num>
American National Standards Institute American National Standard for Information Systems
Coded Character Sets
<num>-Bit American National Standard Code for Information Interchange <num>-Bit ASCII
ANSI X<num>-<num>
<num>
Weitere Revisionen
ANSI X<num>-<num> R<num>
ANSI X<num>-<num> R<num>
ANSI INCITS <num>-<num> R<num>
